I added AI auto-translation to my Notion blog
My blog uses Notion to manage content. Writing articles, editing the introduction, and jotting down casual thoughts can all be done in Notion, and the website then displays this content.Once the blog has English and Japanese versions, there's more content to maintain. After a Chinese article is published, two translations need to be prepared; a few days later, if a paragraph of the Chinese is revised, you also have to remember to sync the changes to the other two languages. And if some translations have already been manually adjusted, you need to watch out when updating so you don't overwrite those changes.I want to keep writing in Chinese while making content in other languages easier to maintain. So I built a translation backend for my blog. (Mainly because I'm lazy)
From Notion to two other languages
The entire workflow can be understood as: read Chinese content from Notion, generate English and Japanese, save the translations, and then publish them to the website.
Notion remains the place where I maintain the original Chinese text; there is no need to create two sets of pages with identical content just for multilingual support. Translations are saved separately, and the website displays them according to the language of the visit.
The translation scope also covers content beyond articles: the homepage introduction, works, musings, journeys, and the about page can all be managed from the same backend.
When someone opens an English or Japanese page, the site directly displays a translation that has already been prepared. The translation work is completed in advance, so readers do not have to wait for AI to generate it on the fly.
The whole process can be divided into five steps:
- Publish or modify Chinese content in Notion.
- The backend reads the published content and checks for missing translations and source text that has changed.
- Call the model to generate English and Japanese translations.
- Validate the results, and save the complete translation and task progress to the GitHub repository.
- After the translated text changes, trigger a Vercel deployment to update the website.
The backend lets me know what happened
These processes ultimately converge into a single management page.
I can view the status of English and Japanese by content category: which ones have not yet been translated, which are in progress, which are completed, and which need to be rechecked because the source text has been updated. If a failure occurs, I can also view the record and resubmit.
When needed, I can translate only one language of a single article, or immediately check all published content.
In addition, I also added an automatic check toggle, which can be set to check hourly, daily, or weekly. When the time comes, the system first determines whether the content has changed, and then decides whether translation is needed. If there is no change, it keeps the existing result.
Update wherever changes are made.
The most straightforward approach is to retranslate the entire article every time the Chinese text is modified. But this both reprocesses content that has not changed and may alter wording that was originally satisfactory.
So, I had the system remember each paragraph's version.
For example, an article already has English and Japanese translations, and later I only modified the second paragraph. On the next check, the system will identify this change, reuse the other paragraphs, and update only the parts that need translation.
You can think of it as proofreading two documents: first find out what changed, then handle those places.
In addition to the main text, the title, abstract, and image captions are also checked separately. Content that has not changed does not need to be requested from the AI again.
Let AI focus on translating text.
Articles in Notion contain more than just text—they also include heading levels, images, links, lists, and code. If you hand the entire piece over to AI to rewrite freely, it’s hard to guarantee the layout and structure after the update.
My approach is to have the program preserve the article's structure, extract the text that needs translation and hand it to the AI, then put it back into the corresponding position after completion.
For example, if a piece of text contains a link, the AI can translate the link label that readers see, while the address the link points to remains unchanged. The positions of images and the code in the body text are also preserved by the program.
This can reduce the impact on other parts of the article during translation. Of course, whether the wording is natural and the tone is appropriate still requires human judgment.
When translation fails, preserve the work already completed.
Automatic translation can also encounter interruptions. The network may time out, the model service may be temporarily unavailable, and a relatively long article may also fail halfway through translation.
To this end, the system saves progress after each paragraph is completed. When run again, it can continue processing the remaining parts, reducing duplicate work.
Saving progress and publishing the translation are separate. Only after the entire translation is complete and it is confirmed that the Chinese original has not changed during processing will the system update the externally displayed version.
If the update fails, readers will continue to see the complete previous version of the translation. Meanwhile, the backend keeps a record of the error so that I can retry later.
A human-corrected translation has to hold up.
AI-generated content can serve as a starting point. Some sentences, though accurate in meaning, don't read in the tone I want to convey; some words also need to be adjusted according to the context of the article.
Therefore, the backend provides a paragraph-by-paragraph comparison. I can look at the Chinese while editing the corresponding English or Japanese.
After saving manually, this paragraph will be locked, and subsequent automatic translations will preserve my revisions. If the corresponding Chinese changes again, the system will mark it as “pending manual review,” reminding me to come back and handle it.
In this way, automatic translation can take on repetitive work, and manual adjustments can also gradually accumulate.
After saving, publish it to the website
The translation is ultimately saved in a GitHub repository. For this personal blog, this allows me to review the history of every change and, if necessary, restore previous versions.
The actual translation tasks are executed in the background by GitHub Actions. After the task is completed and the translated text is successfully saved, the site is redeployed via Vercel so that the new version appears on the website.
Therefore, after clicking “Translate,” it goes through several steps in sequence: processing, saving, and publishing. One role of the backend is to display these statuses so that I know where the content is in the process.
This workflow still has some limitations: automated checks may run with a delay, and after translations are updated, you also need to wait for deployment to complete. As for translation quality, especially tone and subtle meaning, human reading is still required.
For me, the biggest help of this backend is that it gives multilingual maintenance a reusable workflow. I can continue writing in Chinese in Notion, hand the repetitive synchronization work over to the program, and leave my time for the content itself—and for those sentences that deserve careful revision.