4 common localization roadblocks for developers (and how to overcome them)

Localizing your latest app or game isn’t always as smooth as it should be. Localization is a teamwide effort that involves not only the translators and content managers, but developers as well. Read on to discover three common localization challenges development teams can face — then learn the best ways to get around them.
 09-21-2022        Ivan Belcic
4 common localization roadblocks for developers (and how to overcome them)

Challenge: Too much manual work

Software development is a time-intensive job requiring intense periods of concentration. The last thing a development team needs is to get bogged down in an endless series of repetitive manual tasks.

When you localize the old-fashioned way with massive Excel sheets, devs need to copy-paste each string from their code into a spreadsheet, then manually import and export those spreadsheets. And when translations are updated or new strings added, they need to do it again — and again, and again, until the game or app is finished.

Except with the SaaS and GaaS models, nothing is ever truly complete. There’s always new content to create and localize, which means more copy-pasting or importing and exporting for devs when they could focus on improving their creations instead.

Solution: Integrate your content management tools with your game or app

Rather than burden your dev team with a flood of new files, centralize your translations within a content management system (CMS) to create a living, single source of truth for all your original and localized content. Then, connect CMS with your project or channel via API so developers can fetch the content directly from their code. 

This eliminates the need to export a new file for every content update or edit and ensures everyone is using only the most current version of your content.

Gridly’s built-in integrations to both Unreal Engine and Unity enable you to push all your updated content directly into your project — with just a single click. Your devs will never have to copy-paste a string again.

>> Learn more about integrating Gridly with your projects

Challenge: Hard-coded strings

Hard-coded strings are text that’s embedded directly into the code of your software or app. This makes localization much trickier and more time-consuming while also having potential performance implications.

  • It’s near-impossible to maintain version control when each string must be manually updated in the code. And you’ll need to edit each instance of a given string every single time there’s an update.
  • Localization takes exponentially longer. You’ll need to find strings, determine which ones need translating, copy-paste them into an external resource, localize them, then paste each translation back into the code.
  • If strings aren’t reproduced exactly the same way across a project, you may encounter display issues or other performance hiccups.
  • Hard-coded strings can make future product updates more difficult, because the code may be more difficult to understand.

Inexperienced developers are more prone to hard-coding strings. You may also encounter hard-coded strings if the product team wasn’t originally planning to localize their software.

Solution: Store strings in an external content repository

If you’re starting a new project, store strings in a separate resource file or system, such as a content platform or CMS, that can integrate with your app or game. Your content platform should help you manage content via string IDs, assure the IDs are unique across your project, and enable you to create your own strings with IDs. 

Rather than paste the entire string into their code, developers can simply refer to the string ID instead. Your app or game will refer to the external resource, look up the corresponding string for each string ID, then display it where needed.

This flexible system allows for text changes to be made outside of the coding environment, minimizing the risk of introducing coding errors while giving writers more freedom to experiment. Translators and localization writers can work smoothly and efficiently, while developers avoid the painstaking process of pasting new strings across their code every time there’s an update.

If you’re already working with hard-coded strings, it’s not too late to switch over. You’ll need to pull the strings out from your code into your new CMS, then have the development team replace the strings in the code with their respective string IDs. While this can seem like a lot of work, you’ll reap the dividends later in both time and cost savings.

>> Learn more about managing content for localization

Challenge: Localization QA slows down development

The standard approach to localization quality assurance (LQA) is for testers to go through your game or app to confirm that all the translated strings are correctly displayed. If they find a mistake, they’ll need to take a screenshot, upload it, create an issue, then link the screenshot to the related string.

The same goes for voice-overs, videos or gifs, and other multimedia files that frequently need localizing. Testers need to check the project in one place, then report the issue somewhere else. All this back-and-forth can quickly add up.

After an error has been logged, localization writers must update the string and let the dev team know there’s new content to implement — adding yet another bottleneck to the development pipeline. If there’s time, testers will re-check the corrected content. But often, there isn’t — even for small apps and short games, this can take ages.

>> Learn more about localization QA

Solution: Upload media files from your game to your content management platform

A content management platform capable of storing multimedia files empowers QA testers to evaluate everything in one place, without having to manually navigate through your app. With a screenshot, video, or audio file right next to the relevant string, testers can quickly evaluate for accuracy and display issues without leaving their workspace, greatly speeding up the localization testing process.

It gets even better when you can automatically pull screenshots from your game into your CMS. Angry Birds developer Rovio supercharged their LQA process with a simple script that uploaded screenshots of each string in-game to Gridly.

This minor up-front investment of time and effort ended up paying off in spades — as a result, testers were able to perform their work four times faster than before.

Challenge: Maintaining version control

Version control is essential to agile and efficient development. Teams can work on various features simultaneously via branching: when you create a copy of a project that’s separate from the primary, or master, version.

This approach gives developers and content creators a risk-free sandbox in which to experiment without worrying about breaking the entire project. Then, when the new content has been completed and checked for errors, it’s merged back into the master branch.

Agile localization is a similar process in which translators work on new content as it’s created, rather than waiting for the entire project to be complete. But without the ability to branch and merge translated content, there’s always the risk of introducing errors into the master project.

Solution: Use a CMS that supports branching and merging

With branching and merging, you can build a content localization pipeline that is aligned with your development process. Gridly makes it easy to create as many branches as you need, then merge them together with confidence. Your localization writers and developers will be working side-by-side to add new content faster than ever before.

For example, when revamping a project, you can set the master branch to your current version, then create a branch for staging new content. Then, set this staging branch to feed completed content into the staging branch in your development project. When you’re ready to launch, just merge the staging branch into the master one.

Localization writers can run wild in these isolated environments for content creation and staging, with no fear of disrupting the master version. The same goes for working on new content when your game or app is already live. With branches, there’s no risk of accidentally pushing unapproved content before it’s been completely checked for quality.

Streamline your localization workflow with the right platform

Many of the most common localization obstacles for developers can be overcome via a smoother localization process. And creating one begins with the right tools.

Gridly combines the most effective localization features with an intuitive spreadsheet layout for a CMS that’s as impactful on your projects as it is easy to use. Eliminate time-wasting manual labor, speed up your localization QA processes, maintain version control, and so much more.

Ready to find out more! Click down below to discover all Gridly can offer your team:

>> Learn more about managing content with Gridly

>> See what you can do with Gridly’s API

>> Check out Gridly’s docs to learn more about how it works

Localization tips & trends, delivered.

Get the latest posts in your email