What is the L10n & Porting process

It turns a Chinese H5 (Cocos) game into Korean + English builds shipped on Toss (in-app) and
PURE (web). You drive everything from this dashboard; the heavy work (OCR, render, code edits, SDK port)
runs on the assigned developer's machine, and reviews happen here PR-style.

The porting process

Porting one game is a real, multi-role workflow. A developer extracts the text and integrates the Neptune
SDK, the Korean team translates, a designer redraws the baked-image art, and Neptune's PM + testers
review until the build is approved and goes live.

the end-to-end porting process — who does what, from "Receive project" to "Release first live version"

It branches early — localization on one side; SDK / PURE build / StorageManager / safe-area on the other — then
converges into an iterate-until-PM-approves loop before the first live release. The pain points: it spans four
roles, the state is scattered across Notion + DMs + a Sheet, and nothing tells you where a given game actually is.

Our pipeline on this dashboard

This dashboard turns that messy process into one trackable pipeline. Every step has an owner, a status dot,
and — where the process needs sign-off — a review gate. State is shared and realtime, so the whole team can see
where each game stands at a glance.

the same process modelled as a structured pipeline on the H5 Communicate dashboard

It's 4 groups / 12 steps. The Review & Approval / Final Review steps are the PM's review gates and
Redraw assets is the designer's; the rest are the developer's.

Group Steps 1 — Extract · Translate · Sheet

  1. Extract strings → Google Sheet — scan code/prefab/data for Chinese UI text → numeric ids, UPSERTed into the game's Sheet.
  2. OCR images → Google Sheet — detect text-images (Claude or Paddle engine) and UPSERT them by path.
  3. Translate → KO & EN — translate the whole Sheet to Korean and English.
  4. Review & Approval — the Korean team fills the KR column; dev requests review; the PM approves.

Group Steps 2 — Porting & Apply

  1. Onboard SDK + wire + integrate — drop the real Neptune SDK (picked by detected Cocos 2.x/3.x) and wire boot.
  2. Apply Localized texts → Source — write KR into language.json, rewrite data tables, inject LanguageComponent.

Group Steps 3 — Redraw assets

  1. Hand-off assets → Designer — push the CN image originals to the designer's Drive folder.
  2. Redraw assets — the designer redraws one version per target language and uploads them.
  3. Review & Approval — the PM approves the redrawn assets.

Group Steps 4 — Build & Final Check

  1. Apply Localized images → Source — copy the reviewed images next to the originals, one per language (<name>_ko.png, <name>_en.png, …).
  2. Build & deploy — dev fine-tunes in Cocos, CI builds the PURE/Toss target.
  3. Final Review — the PM verifies the build end-to-end and marks the project completed.

Each step maps 1:1 onto a node in the process above — same owners, same order — only now it's clickable, status
is tracked, and the three review gates run as PR-style review cycles instead of Notion threads + DMs.

Everything is realtime — status, comments and review changes appear live for everyone on the project.