If you search for localization value type QA, JSON translation schema errors, or string versus object mismatch in locale files, the problem is structural: the same resource key can exist in source and target while its value changes type. A source string becomes an object, an array becomes a string, a number becomes localized prose, a boolean becomes “true”, or a null value becomes an empty string.
A fast localization QA workflow therefore validates value shape as well as key presence. Missing-key QA can report perfect parity and build validation can report valid JSON, yet runtime code still fails because one locale returns an array where the application expects a string. Type drift is especially common after manual merges, spreadsheet round trips, YAML coercion, JSON editing and schema migrations.
This guide explains how people translate quickly by validating resource value types before release. It covers JSON strings, objects, arrays, numbers, booleans, null, YAML scalars, schema parity, arrays of messages, nested locale structures, plural objects, typed APIs, generated resources, CI, migration rules and safe remediation.
The owner job is distinct from Missing Keys, Extra Keys and Empty Target QA. Those checks ask whether a resource exists and contains target content. Value-Type QA asks whether the resource is still the same kind of data the application expects.
1. JSON Has Distinct Value Types
JSON values can be objects, arrays, numbers, strings, true, false or null. A localization file can therefore be syntactically valid even when one key changes from a string to another JSON type.
Runtime code may fail only when that key is requested. QA should compare type as part of resource identity. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
2. A String Becoming an Object Is a Real Contract Change
A source key may contain “Save” while the target accidentally contains {“label”:”Save”}. Both are legal JSON values.
Code expecting a string can render [object Object], throw, or reject the value. Key parity alone cannot catch the mismatch. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
3. An Object Becoming a String Can Flatten Structure
A source object may contain title, body and button fields while a target editor replaces it with one translated sentence. The file still parses if the syntax is valid.
The application then loses the nested fields it expects. Structured localization requires shape preservation as well as language quality. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
4. Arrays Need Positional and Type Checks
A source array can represent ordered labels, steps or options. Replacing it with a comma-separated string destroys the data model even if all words are translated.
Compare array versus scalar type before inspecting wording. Then verify element count and element types where the schema requires them. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
5. Numbers Are Not Translatable Prose
A numeric configuration value may sit beside user-facing strings in the same locale file. Changing 3 to “three” changes the type and can break calculation or validation.
Only human-readable number formatting should be localized at the rendering layer when the architecture calls for it. Keep machine values machine-readable. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
6. Boolean Values Must Stay Boolean
JSON true is not the same data type as the string “true”. Spreadsheet and manual editing can convert booleans into text.
Code using strict type checks may behave differently. Type QA should distinguish literal booleans from translated words such as “yes” or “no”. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
7. Null Is Not the Same as an Empty String
JSON null can mean no value, unknown value or explicit absence according to the application. An empty string is still a string and can trigger different fallback or validation behavior.
Do not normalize null, missing and empty into one category automatically. Project schema should define the semantic difference. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
8. Missing Is Not a JSON Value Type
A key that does not exist is structurally different from a key whose value is null. Missing-key QA owns absence; Value-Type QA owns the type of present values.
Keeping the distinction prevents confusing repair paths. One can require a new key while the other may require a schema-correct value. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
9. YAML Can Coerce Scalars Unexpectedly
YAML parsers can interpret unquoted scalars as booleans, numbers, null-like values or strings depending on version and parser rules. A translated word may accidentally resemble a special scalar form.
Quote values deliberately where the project requires strings. Test with the actual YAML parser used by the application. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
10. Leading Zeros Can Turn Identifiers Into Numbers
A value such as 00123 may be intended as an ID string. Spreadsheet or YAML handling can convert it to 123.
The visible change looks small but identity has changed. Schema should mark identifiers as strings and validate after round trips. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
11. Scientific Notation Can Appear Accidentally
Long numeric-looking IDs can be converted by spreadsheets into scientific notation. After export, the locale file can contain a number or altered string instead of the original identifier.
Protect ID columns and validate types. Do not rely on spreadsheet display as evidence of exact data. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
12. Arrays of Strings Need Element-Type Parity
A source array can contain only strings while a target contains one object, number or null. The top-level array type still matches.
Deep type validation should inspect element schemas where required. Shallow parity is not enough for structured messages. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
13. Objects Need Required-Field Checks
A target object can preserve the object type while losing one required child field. That belongs partly to key/schema parity, but type-aware schema validation can catch it together with the shape contract.
Use required-property rules for structured resources. Nested localization needs nested validation. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
14. Plural Objects Are Structured Messages
Some systems store plural variants as objects such as one, other or zero. Flattening them into one target string breaks grammatical selection.
Validate object structure before checking plural quality. Message-format owners can then inspect category completeness. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
15. Select and Gender Objects Need Similar Care
Locale resources can store variants by gender, status or other selection keys. One locale may legitimately have different variant sets if the framework permits it, but the base data type still matters.
Use schema rules that reflect the message system. Do not force simple parity where language architecture intentionally differs. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
16. Typed Localization APIs Depend on Stable Shapes
Modern code generation can expose locale resources through typed interfaces. A type mismatch can fail compilation before runtime, which is helpful.
Keep generated type checks in CI. Translation artifacts should satisfy the same contract as source resources. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
17. Untyped JavaScript Can Hide Drift Longer
Dynamic languages may accept a wrong value type until a specific UI path executes. That makes pre-release schema checks more valuable.
Use runtime assertions or JSON Schema where appropriate. Flexible syntax increases the need for explicit contracts. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
18. Schema Validation Can Catch Type Drift Deterministically
JSON Schema and similar systems can define whether a key expects string, number, boolean, array, object or null. Validation can run before localization import and after export.
This removes subjective interpretation from a structural rule. Use schema errors as routing information, not language criticism. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
19. Schemas Can Allow Multiple Types Intentionally
Some APIs permit a value to be either string or null, or number or string, by design. QA must reflect the real contract rather than demanding one type universally.
Multiple-type schemas should still be explicit. Intentional flexibility is different from accidental drift. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
20. Do Not Broaden the Schema to Silence Bad Data
When a target file fails type validation, changing the schema to accept every observed type hides the underlying defect. Broaden only when the application genuinely supports the new type.
Validation should describe reality, not accommodate mistakes. False flexibility creates future ambiguity. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
21. Do Not Auto-Cast Without Semantics
Converting “123” to 123 or null to “” automatically can change application behavior. Type repair should follow the source schema and product meaning.
Use automated casts only where the contract explicitly defines them. Mechanical conversion is not always semantic preservation. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
22. Source and Target Types Usually Match
For ordinary localization resource files, a source string should normally remain a target string. Numbers, booleans and structural objects should normally preserve their data roles.
Language differences usually change content, not application type. Unexpected type changes deserve review. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
23. Some Locale Architectures Intentionally Differ
A target locale can contain extra nested structure for region-specific overrides or message variants. That is acceptable only when the runtime loader understands it.
Document the exception in the schema or resource model. Do not rely on translators to remember invisible architecture. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
24. Spreadsheet Handoffs Are High Risk for Type Drift
Rows and cells blur distinctions between numbers, booleans and strings unless columns are typed deliberately. A value exported back to JSON can emerge with the wrong native type.
Protect schema during import and export. Flat review surfaces should not redefine structured data. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
25. CSV Is String-Oriented Unless Conversion Rules Say Otherwise
CSV fields arrive as text unless an importer applies type inference. Automatic type inference can turn locale IDs, booleans or numbers into native values unexpectedly.
Define conversion rules per column. Do not let generic spreadsheet heuristics choose resource types. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
26. CMS APIs Can Change Types During Serialization
A CMS can store one value as rich text, plain text, array or structured block data depending on field configuration. Localization connectors must preserve the field schema.
Do not flatten structured CMS content into strings unless the integration owns that transformation. Connector contracts are part of localization QA. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
27. GraphQL and REST Schemas Offer Strong Signals
Typed APIs already describe expected value shapes. Localization sync tools can validate responses against those schemas.
This catches wrong types before content reaches translators or products. Reuse existing application contracts instead of inventing parallel rules. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
28. Database Columns Can Impose Type Contracts
Localized data stored in typed columns can reject or coerce incoming values. An integer or boolean field should not be used as a translation surface unless the architecture intends it.
Keep language in language-bearing fields. Database validation can reinforce resource QA. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
29. Null Handling Often Affects Fallback
A null target may trigger fallback while an empty string may suppress fallback, depending on the framework. Value type therefore changes runtime resolution.
Coordinate type QA with Locale Fallback QA. Presence and type can both affect what users see. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
30. Boolean Flags Should Usually Not Be Localized
Feature flags and configuration booleans can appear in locale-adjacent files. Translators should not replace true/false with translated words.
Separate configuration from translatable content where possible. Good architecture reduces type-risk exposure. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
31. Numbers Can Be Display Content or Machine Data
A string “1,000” may be user-facing localized text while numeric 1000 is machine data. The same visible concept can legitimately use different types at different layers.
Schema and field role determine the correct representation. Do not infer type from the human meaning alone. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
32. Rich Text Blocks Are Not Plain Strings
CMS and design systems can represent text as arrays of spans, nodes or blocks. Flattening structured rich text to one string loses formatting and metadata.
Use structure-aware localization connectors. Type QA protects content models as well as code resources. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
33. HTML Strings Are Still Strings
A resource containing markup can remain a string even though it encodes internal HTML structure. Do not convert it into an object merely because a parser can interpret the markup.
Inline-tag QA owns markup validity. Value type and internal grammar are separate layers. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
34. ICU Messages Are Usually Strings With Internal Syntax
An ICU message may contain plural/select logic while still being serialized as a string. Do not confuse message-language complexity with JSON object type.
ICU syntax QA should parse the string separately. One value can have several layers of structure. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
35. Typed Resources Improve Translator Context
When a translator knows a field is enum, number, boolean or structured object, accidental editing becomes less likely. Expose non-translatable types clearly or lock them.
Do not present every scalar as editable prose. Tooling should reflect the data model. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
36. Lock Non-Translatable Native Values
If a locale file mixes strings with configuration numbers or booleans, CAT import filters can exclude non-string values. That reduces both workload and risk.
Preflight should identify which types are actually translatable. Structural filtering is faster than repeated warnings. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
37. Source Changes Can Migrate a Key’s Type
A product refactor may intentionally change one key from string to object to support richer content. Every target locale then needs a migration, not a simple translation update.
Version-diff QA should surface the schema change. Type migration deserves explicit project planning. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
38. Target Files Can Lag Behind Schema Migrations
A source moves to an object structure while older locale files still contain strings. Key names remain the same, so parity checks appear clean.
Value-Type QA catches the stale shape immediately. This is one of the strongest uses of the check. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
39. Type Drift Can Create Silent Fallback
A runtime may reject the target value and fall back to source or default content. Users see readable text, so the structural defect stays hidden.
Trace rejected or fallback-resolved resources. Type errors can masquerade as incomplete localization. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
40. Type Drift Can Create Stringification Artifacts
JavaScript can render an object as [object Object] or an array as comma-joined text when code coerces values. Those symptoms point to type mismatch rather than bad translation.
Inspect the runtime value before editing the target words. UI weirdness often reveals a lower layer. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
41. Type Drift Can Break Interpolation
Formatting code may call string methods on a value that became null, number or object. The application can throw only when that locale and key are used.
Schema validation is cheaper than exhaustive runtime discovery. Structural QA should prevent avoidable locale-specific crashes. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
42. Type Drift Can Break Sorting and Comparison
A numeric value stored as a string sorts lexically, so “10” can precede “2”. A boolean stored as text may evaluate truthily in dynamic code.
Localization artifacts should not change computational semantics. Type parity protects behavior beyond rendering. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
43. Array Order Can Be Semantic
An array can represent ordered workflow steps or menu items. Even when element types match, spreadsheet sorting can reorder them.
Type QA can pair with order or identity checks where arrays are positional. Structure includes sequence as well as type. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
44. Object Property Order Usually Should Not Carry Meaning
JSON object member order should not be the primary semantic contract. Localization tools may reorder properties.
Use keys, not object position, to identify content. Type and key presence matter more than visual ordering. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
45. Nulls Need Explicit Lifecycle Rules
A null can mean not yet translated, intentionally unavailable, inherited, or unknown. Choose one meaning per field or schema.
Otherwise reviewers cannot tell whether null is valid or a defect. Semantic clarity reduces false positives. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
46. Empty Arrays and Empty Objects Need Context
An empty array [] is not the same as null, and an empty object {} is not the same as missing. The application may treat each state differently.
Validate against business rules as well as type. Structural emptiness deserves explicit semantics. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
47. Type QA Should Run Before Linguistic QA
If a target object is where a string belongs, a reviewer should not spend time editing wording first. Technical validation can fail fast and route the artifact for repair.
Language review becomes more efficient after structure is trustworthy. Order the pipeline from deterministic checks to human judgment. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
48. Type QA Should Run After Export Too
A CAT or connector can serialize every target as a string even if source files contained native numbers and booleans. That means the project can be correct internally and wrong after export.
Validate the returned artifact. Round-trip fidelity is part of the type contract. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
49. CI Can Compare Type Trees
Flatten source and target structures into path → type maps and compare them under project rules. Report mismatches before merge or release.
Allow explicit exceptions for locale-specific architecture. Type-tree diffing is deterministic and scalable. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
50. Warnings Should Show Source and Target Type
A useful message says checkout.timeout: source number, target string. Include file, locale and raw values where safe.
This immediately tells the owner what changed. Generic ‘schema error’ messages slow remediation. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
51. Do Not Expose Raw Objects to Translators Accidentally
Localization tools can stringify objects to JSON text and present them as editable content. That invites syntax damage and type loss.
Use structure-aware extraction or lock the field. Tooling should match the schema. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
52. Fix the Authoritative Layer
If type drift comes from a connector, spreadsheet conversion or generator, repair that stage rather than hand-editing every locale. Regenerate targets after fixing the source pipeline.
Systemic defects need systemic fixes. Localization QA should reduce repeated manual repair. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
53. Resource Value-Type QA Complements Build Validation
A file can parse and compile while returning the wrong native value type to code. Build validation proves syntax; type QA proves schema.
Both can be automated. Layered checks catch different technical failures. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
54. Resource Value-Type QA Complements Empty Target QA
An empty string is a string; null is a null; an empty object is an object. All may look ’empty’ to a human but mean different things to code.
Use Empty Target QA for missing visible translation content and type QA for native data shape. Clear owners reduce ambiguity. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
55. Resource Value-Type QA Complements Key-Parity QA
Source and target can contain exactly the same keys while values have incompatible types. Parity proves presence, not shape.
Run type comparison after key comparison. Completeness and compatibility are separate dimensions. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
56. Keep Schema Versions With Releases
If the localization data model changes, version the schema alongside source resources. Vendors and CI can validate against the same contract.
Do not let old locale files be judged by undocumented new assumptions. Schema versioning makes migrations explicit. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
57. Test Representative Runtime Paths
Even strong schema validation should be paired with a small runtime smoke test. Load a string, array, object, numeric and nullable resource through the same API the product uses.
This verifies that serialization and loader behavior match the schema. Executable evidence closes the loop. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
58. Treat Type Incidents as Pipeline Feedback
If wrong types recur, identify whether they originate in hand editing, YAML coercion, spreadsheets, connectors or code generation. Fix the earliest repeatable source.
The long-term objective is stable typed resources, not better emergency cleanup. QA findings should improve architecture. The right answer comes from the application’s schema and field role, not from what looks most natural in a text editor.
A practical review step is to compare source and target type trees, inspect explicit exceptions, validate with the product schema, repair the authoritative transformation layer, and rerun both technical and runtime smoke checks before linguistic review closes.
Practical Resource Value-Type QA Workflow
Define or infer the source resource schema before translation begins.
Compare source and target path-to-type maps for every locale.
Validate nested array elements and required object properties where relevant.
Keep null, empty string, missing key, empty array and empty object semantically distinct.
Exclude non-translatable configuration values from CAT extraction where possible.
Run schema validation after import, merge and final export.
Smoke-test representative values through the application’s real resource loader.
Worked Example: A String Turns Into an Object
A source JSON resource contains checkout.confirm as the string “Confirm purchase”. A localization spreadsheet import mistakenly treats a dotted column mapping as nested structure and exports the French target as checkout.confirm: {“text”:”Confirmer l’achat”}.
The JSON is valid and the key exists, so syntax, key-parity and missing-key checks all pass. The React component expects a string and renders an object error only in French.
Resource Value-Type QA compares the source and target type trees and reports source string versus target object before release. The spreadsheet connector is fixed and the locale file is regenerated.
The translation wording was correct. The failure belonged to data shape, and a deterministic type check caught it before users did.
Frequently Asked Questions
Should source and target value types always match?
Usually yes for ordinary localization resources, unless the runtime explicitly supports locale-specific structures. Any exception should be documented in the schema.
Is null the same as an empty translation?
No. null is a native value type; “” is an empty string; a missing key is structural absence. They can trigger different fallback and validation behavior.
Can JSON parse successfully with the wrong types?
Yes. JSON syntax allows many value types. A file can be valid JSON while violating the application’s expected resource schema.
Can CI automate type QA?
Yes. Compare source and target schemas or path-to-type maps and validate with JSON Schema or platform-native types.
Why not convert every value to a string?
Because numbers, booleans, arrays, objects and null can carry application semantics. Stringifying them can break logic, formatting and fallback.
Current JSON Practice
RFC 8259 defines JSON values as object, array, number, string, true, false or null. A syntactically valid JSON document can therefore contain the wrong application-level value type even when every key is present. See RFC 8259.
Typed schema systems such as JSON Schema can constrain those native types further, including nested object properties and arrays. The localization lesson is to validate the resource contract before asking linguistic reviewers to diagnose runtime symptoms.
Conclusion
Resource Value-Type QA protects the data model beneath translated words.
A fast workflow compares type trees, keeps null and empty states distinct, validates against explicit schemas and repairs connectors or generators rather than hand-fixing every locale.
When resource shape stays stable, translators can change language freely without changing the application’s contract.
Continue the Translation Series
Read How People Translate Quickly | Missing Localization Keys QA.
Read How People Translate Quickly | Empty Target QA.
Read How People Translate Quickly | Localization Build Validation.