How to translate your software product effectively? Localization tips

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.

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.