How to translate your software product effectively? Localization tips

People around the world expect content to appear in their native language, be it Norwegian, Italian, Chinese, Japanese, Ukrainian, or another language. There are so many languages worldwide that if you're a software vendor and your clients are trying to expand the business into new markets, it's important to translate applications to be with the target audience on the same page.

We at Axon know that the localization process is a crucial stage in developing and promoting software. Technical documentation, inscriptions on interface elements, accompanying files - all this must be translated and adapted to cultural and social characteristics. For the last nine years, Axon has produced plenty of custom web and mobile applications serving clients globally, speaking in different languages. Thus, most of these apps required translation. Moreover, our software engineers have developed a special tool to automate the localization process on the projects and organize all translations in one place. But first things first.

This material is intended to determine the engineering challenges during the software localization process and find professional tips to overcome them.

Localization and Translation

Localization allows the application to be consistent, that is, adaptive, but at the same time logical for a specific country and language that the user speaks.

What extra value does your customer get from the localization?

To take the business beyond the borders and expand its reach, clients need to create an application that can serve users in their native language. In addition, there are other advantages of creating a multilingual application:

• Localization of the brand with minimal costs;
• Improved customer satisfaction thanks to the personalized experience;
• Reduced support costs due to the better readability and understanding of the initial functionality;
• Easier process of responding to user inquiries and explaining products and services;
• Saved time, energy, and resources when taking the business to international markets;
• New level of conversions and retention rates.

Localizing content helps to improve SEO optimization. If your customer has multiple website versions translated into different target languages, its visitors can find the most appropriate page for them. Thanks to SEO localization, you will significantly improve the effectiveness of Page Titles in reaching the target audience and increasing conversions and brand awareness.

When talking about applications, localizing your app's metadata, including the app name, description, keywords, and screenshots, helps improve its discoverability in various app stores. When users search for apps in their preferred language, localized metadata increases the chances of the app appearing in relevant search results. Data from the App Store state that 70% of App Store visitors use search to find the desired app, while two-thirds of installs come from search.

Challenges in Localization and Translation

When we look at the work involved in localization, we can quickly recognize that it is a challenging task due to the elements, components, and resources that will be required. However, many people make serious mistakes when localizing their websites or applications:

1. Wrong choice of translation method

When translating software solutions, there are human translation and machine translation.

• Human translations:

Professional translators render your software solution page by page in the target language from the source language. But they aren’t technically oriented: they can’t handle the technical part of hosting or integrating the translated content into your site; for this, you’ll need the additional services of a software engineer. Also, this method isn’t economically viable because you will need several professional translators for each language of your project.

• Machine or automatic translation:

Machine translation is faster and more cost-effective than a human one, even if you will engage a responsible person for proofreading. This is the best way to translate your application from beginning to end.

When choosing a translation method, pay attention to the right balance of cost, service, accuracy, and speed.

2. String externalization

Developers must externalize all user-facing text strings in their codebase to prepare them for translation. This process involves identifying and extracting these strings from the code and storing them in a separate resource file or database. Ensuring proper string externalization can be time-consuming and requires attention to detail.

3. Neglect of optimization

Website is a huge part of the traffic that can lead potential users to your application. All website owners usually want their website to be visible and understandable to anyone anywhere. And for this, the implemented SEO strategy must be multilingual. Optimize the tags for international SEO, translate site content and metadata, and don’t forget about language-specific subdomains and subdirectories.

Thus, poor localization can significantly impact user experience and customer satisfaction. Only accurate or well-translated text can eliminate misunderstandings, making it easier for users to navigate and comprehend the product or service.

Practical Tips for Engineers To Optimize the Localization and Translation Workflows  

Localization is an important aspect of any system, involving all its components. On the client-side, it involves localizing screens, buttons, and user-visible messages. The server-side is responsible for emails, downloaded files, and sometimes error messages.

Setting up a test environment is crucial in the software localization process, as it allows for comprehensive testing and quality assurance to ensure that the translated product functions correctly and meets the needs of the target audience.

Plan localization

It's highly recommended to include localization in the planning stage. Even if a business has yet to make plans to expand its application beyond one language, adopting a multi-language approach in the code base is still beneficial. This simplifies translation management and potential scaling, improves efficiency, and minimizes probable mistakes.

Use string identifiers

To implement localization effectively, our specialists recommend using string identifiers (also known as keys, key identifiers, or placeholders) in the code whenever text is displayed to the user.

These string identifiers should be clear and easily understandable for developers and translators. They should have common formats. Often, it is a snake case, i.e., error_internal_error. String identifiers can be applied to any software, whether it's a mobile app, website, game, IoT application, or standalone software. Creating constants for string identifiers enables easy modification of keys and tracking their usage during development.

<Stack
        direction={{ xs: 'column', sm: 'row' }}
        spacing={4}
        mt="auto"
        mb={4}
        px={4}
        zIndex={10}
      >
        <Typography variant="caption2" color="text.secondary">
          {t('common.all_rights_reserved')}
        </Typography>
        <Link to={paths.privacyPolicy}>{t('common.privacy_policy')}</Link>
        <Link to={paths.termsOfService}>{t('common.terms_of_service')}</Link>
        <Link to={paths.cookieSettings}>{t('common.cookie_settings')}</Link>
      </Stack>

Store the actual texts in localization files, with one file per language. These files establish the mapping between the string identifiers (keys) and their corresponding translation values. The format of the file may vary depending on the platform. It can be JSON, AppleStrings, XML, etc.

{
            handleFileDrop(file!)
            setError(false)
          }}
          onReject={([fileRejections]) => {
            const errorCodes = fileRejections?.errors.map(error => error.code)

            if (errorCodes) setError(true)

            toast.error(
              <Box display="flex" flexDirection="column">
                <Typography
                  variant="caption2"
                  color="text.primary"
                  fontWeight={600}
                >
                  {t(`components.dropzone.file_cant_be_uploaded`)}
                </Typography>

                <Stack>
                  {errorCodes?.map(error => (
                    <Typography
                      variant="caption3"
                      color="text.primary"
                      mt={0.5}
                      key={error}
                    >
                      {errorCodes.length > 1 ? `• ` : ''}
                      {t(`dropzone_errors.${error}`)}
                    </Typography>
                  ))}
                </Stack>
              </Box>,
            )
          }}
          isError={isError}
        >
          <Typography
            variant="caption3"
            color={isError ? 'error.main' : 'text.secondary'}
            mt={1}
            textAlign="center"
          >
            {t('components.dropzone.supported_format', {
              format: SUPPORTED_FILE_FORMAT,
            })}
            <br />
            {t('components.dropzone.file_max_size', { fileSize: '5mb' })}
          </Typography>
        </DropZone>

Choose a localization tool

Using an effective localization tool can greatly simplify the synchronization of translations between your code and translators. Such a tool often provides features for importing and exporting localization files, which is more reliable than manually copying and pasting keys and texts. Moreover, if the service offers integration with GitHub, you can easily create a pull request with updated translations at the click of a button.

When utilizing a localization tool, it's important to tag or provide descriptions for the keys to provide context for the required text to the translator. This helps them understand the purpose and usage of each translation, resulting in more accurate and contextually appropriate localized content.

To make the translation easy and customized to the project needs, our software engineers have built Libraria. This localization platform allows teams to manage all translations for web and mobile applications in one place and go global faster. Libraria's main features include:

• Collaboration - create localization projects, invite your team members, and track the progress;
• Automation - fetch your translation updates to the codebase thanks to the GitHub integration;
• ChatGPT integration - create better translation with suggestions provided by the AI assistant.

This solution helped us to make localization super fast. Now there is no time wasted for developers and project managers and zero time for integration.

Case Study: Adapting Software to Multiple Languages

At Axon, we had experiences in both starting projects from scratch and working with existing codebases. And we know that at some point, a business wants to expand its network of users and make the system more friendly to them. Often it includes adding support for one or several languages.

The decisions made during the planning stage play a crucial role. If your project adopts a multiple languages approach, utilizes string identifiers, and uses a localization tool, scaling up be implemented faster and softer. And everything that your need is to translate texts and add them to new localization files for all platforms.

Otherwise, if these considerations were overlooked initially, the process can be a little longer, but with proper planning and a clear understanding of the steps, it can be easily managed.

In our recent project, an Applicant Tracking System (ATS), where the system initially supported English only, we aimed to add an extra language. We had already implemented support for multiple languages and utilized string identifiers from the start. It's important to note that using user-visible texts directly in the code is not considered a good practice.

Step 1: Addressing placeholder mapping

If your project misses this aspect, addressing it in the next phase is imperative. So, defining the list of placeholders, mapping them with actual messages in a separate file, and using them in code is the first step. Although this work may seem repetitive and monotonous, it requires precision and attention because minor errors or oversights in keys and translations can frequently occur due to manual input.

Step 2: Integrating localization tool into the translation workflow

The subsequent stage was incorporating Libraria as the chosen localization tool into our workflow. It offers all necessary features covering project needs, such as import and export files, integration with GitHub repositories, translation, and improving texts with OpenAI.

We used the option to fetch existing translations from the project's GitHub repository instead of manually copying and pasting keys and texts into the service. This approach proved to be more stable and efficient.

Step 3: Performing translation

The next step is the actual translation process. As we have mentioned before, there are several options to reach it, such as using translator tools, leveraging OpenAI, involving human translators, or combining ways. The choice depends on the target language, application content, and business requirement. In the case of the ATS, we asked natives for help and used ChatGPT suggestions. With Libraria's integration with OpenAI, we were able to translate texts using ChatGPT seamlessly within the project page.

Libraria allowed us to manage the project team, making it convenient to involve external translators who can work directly with the service without any additional communication channels to share translations.

Step 4: Finalizing translation process and repository update

Once the translation process is finished, all that remains is to push made changes back to the repository. The service will update localization files and generate a pull request with the new commits. The pull request needs to be reviewed and merged manually, allowing any necessary changes to be made.

After the pull request is merged and code changes are applied, the application service can be redeployed to show the new translations to users.

Also, it is important to ensure that new languages are added to the list of available options for users to select from. This enables users to choose their preferred language from the expanded list of available languages.

Conclusion

Localizing your software solution means that you personalize it. Any organization looking to grow must think about the localization of software development solutions. Due to much effort and resources spent on localization, it may sound like a great concern for many business owners and developers. Fortunately, there are tools and solutions to make the job easier. These tools will allow you to avoid the falls and shortcomings that many have experienced.