How People Translate Quickly | Capitalization QA: Catch Wrong Case in Brands, Headings, UI Labels and Sentence Starts Without Flattening Target Style

People searching capitalization QA translation, CAT tool capitalization check, uppercase lowercase translation QA, capitalization inconsistency localization, translation capitals check, or wrong case in translated text are trying to catch a visually small defect that can carry brand, grammatical, interface, or legal meaning. A translation can be semantically correct and still look wrong because a product name lost its internal capital, a heading inherited source title case, a sentence begins in lowercase, or an acronym was silently normalized.

Current CAT and localization systems continue to treat capitalization as a distinct QA layer. Smartcat’s current CAT positioning explicitly includes capitalization inconsistencies among automated QA concerns, while memoQ’s QA settings separate capitals from punctuation, spaces, characters, terminology, and tags. This separation makes sense: capitalization is not just typography. It can mark sentence boundaries, proper names, acronyms, branded spellings, headings, UI conventions, and defined legal terms.

This article has one dominant reader job: use capitalization QA to find wrong case quickly while preserving target-language capitalization rules, brand spellings, acronyms, and intentional lowercase or uppercase forms. It does not replace spellcheck, terminology QA, style guides, or the broader whitespace-and-punctuation pass. Its job is narrower: identify suspicious case differences, classify whether they matter, correct them consistently, and reduce repeated manual scanning.

Quick answer

A reliable capitalization-QA workflow is:

1. define target-language capitalization rules before translation;
2. identify case-sensitive product names, brands, acronyms, defined terms, and UI conventions;
3. run capitalization checks or project-specific case-sensitive QA;
4. prioritize sentence starts, proper names, product terms, headings, buttons, and legal definitions;
5. distinguish source-driven case from target-language style;
6. do not copy English title case into languages that do not use it the same way;
7. use termbase metadata for exact branded casing;
8. use regex or custom checks only where native capitalization QA is insufficient;
9. rerun after reviewer edits, global replacements, imports, and case normalization;
10. finish with target-only visual review for headings and interface strings.

The central rule is:

preserve case when it carries identity or target-language function; change case when target conventions require it.

Why capitalization errors are easy to miss

Readers recognize words mainly from their letters and context.

Compare:

• AcmeCloud
• Acmecloud
• ACMECLOUD
• acmecloud

A human may understand all four.

A brand team may accept only one.

The same is true for:

• eSIM;
• iPhone;
• PowerShell;
• JavaScript;
• OpenAI;
• GitHub.

Case is part of identity.

A fluent translation can therefore contain a brand error that spellcheck never flags.

Capitalization has several jobs

Sentence grammar

Many languages capitalize sentence starts.

Proper names

People, places, institutions.

Brand identity

Exact stylized case.

Acronyms

API, CPU, GDPR.

Headings

Title case, sentence case, all caps, or locale-specific conventions.

Interface labels

May follow product style.

Defined legal terms

Capitalization may signal a specially defined concept.

Emphasis

ALL CAPS can be rhetorical or operational.

One QA rule cannot treat every case difference identically.

Step 1: define target-language case policy

Before checking errors, decide what correct target casing looks like.

Useful questions:

• Does the target use sentence case for headings?
• Are UI buttons sentence case?
• Are months capitalized?
• Are language names capitalized?
• Are formal pronouns capitalized?
• Which product names have nonstandard case?
• Are acronyms preserved?
• Are legal defined terms capitalized?

The source is evidence.

The target style guide is authority.

Source capitalization is not always target capitalization

English source heading:

Account Security Settings

A target language may naturally use sentence case:

Account security settings

If the translator copies title case word by word, the target can look foreign even though every word is correct.

Capitalization QA should protect target norms, not source appearance.

Worked example 1: English title case into a sentence-case locale

Source:

Manage Your Payment Methods

Target style requires sentence case.

Correct target:

[Equivalent of “Manage your payment methods” with only normal target capitalization]

A naive source-target capitalization check might expect every major word to remain capitalized.

That would be wrong.

QA configuration must understand the target style.

Worked example 2: brand case

Source:

Sign in with GitHub.

Target:

Sign in with Github.

Meaning is clear.

Brand spelling is wrong.

If GitHub is stored as an exact case-sensitive term, terminology or capitalization QA can flag it.

Worked example 3: acronym lowercased

Source:

Connect the USB cable.

Target:

Connect the usb cable.

Some style environments may tolerate common lexicalized acronyms.

Others require exact uppercase.

Project policy decides.

Step 2: store branded capitalization as terminology

Do not expect translators to remember:

• eBay;
• iOS;
• macOS;
• PowerPoint;
• YouTube.

A termbase entry can carry the approved form.

Benefits:

• suggestion appears;
• glossary compliance can compare;
• review becomes consistent.

Case-sensitive terminology is stronger than a general capitalization rule for brand names.

Step 3: distinguish case-sensitive and case-insensitive terms

Not every term needs exact case everywhere.

Example:

server

Sentence start:

Server…

Mid-sentence:

server

A termbase that demands lowercase server everywhere would be wrong.

Brand:

ServerX

may require exact case.

The terminology resource should encode which case is identity-bearing.

Step 4: sentence starts

Common defect:

the user can continue.

after a period or segment start.

Causes:

• source copied;
• merge/split;
• reviewer edit;
• MT;
• lowercased term insertion.

A sentence-start capitalization check is high signal in languages where this convention applies.

But exceptions exist.

Examples:

• iPhone begins with lowercase i;
• code starts with lowercase identifier;
• stylized brand begins lowercase.

Do not uppercase automatically.

Sentence-start case and brands

Target:

iPhone is connected.

Correct.

Automatic “capitalize first character” could produce:

IPhone is connected.

Wrong.

The rule must operate on language, not merely first character.

Step 5: sentence starts after tags

Source may begin with formatting:

<b>Important:</b> ...

The first visible word can occur after a tag.

Capitalization QA should inspect visible text rather than raw tag order.

This is another reason CAT-aware checks outperform simple plain-text macros.

Step 6: headings

Headings create many case errors because source and target style diverge.

Possible systems:

• Title Case;
• sentence case;
• ALL CAPS;
• lowercase branding.

Define one by content type.

Do not let each translator choose.

Heading case and SEO

Public web headings may use search-intent phrasing but should still follow site style.

Capitalization should not be manipulated to “stuff” keywords.

Readers and search engines understand normal case.

Use language naturally.

Step 7: UI labels

UI teams often specify:

• sentence case buttons;
• title case menu items;
• uppercase tabs;
• exact source product labels.

One application can use several conventions.

String context matters.

Use:

• screenshots;
• keys;
• developer notes.

Capitalization QA without UI function can overcorrect.

Worked example 4: button versus heading

Source:

Continue

Target appears in:

• button;
• section heading.

Target language may use different case rules for each.

Same source.

Different target capitalization.

Consistency QA may flag.

Context resolves it.

Step 8: legal defined terms

Contracts often define terms:

“Services” means…

Later:

The Services will…

Capitalization signals the defined concept.

If the target legal style preserves defined-term capitalization, losing the capital can blur whether the word is generic or defined.

Legal capitalization can therefore carry semantic scope.

Defined-term QA

For high-risk legal translation:

1. list defined terms;
2. record approved target forms;
3. enforce case-sensitive terminology;
4. search generic lowercase collisions;
5. review context.

This is more precise than general capitals QA alone.

Step 9: personal and place names

Most names have stable capitalization.

But particles and conventions vary:

• de;
• van;
• von;
• al-;
• Mc;
• Mac.

Do not normalize names using English intuition.

Use authoritative spelling.

Step 10: institutional names

Organizations may publish official target-language names with specific capitalization.

Use official references.

Do not infer case from source.

Step 11: camelCase and PascalCase

Technical content contains identifiers:

• camelCase;
• PascalCase;
• snake_case;
• kebab-case.

These are code structures.

Changing case can break functionality.

Examples:

• userId
• UserID
• user_id

They may be distinct identifiers.

Treat code tokens as protected.

Case-sensitive file systems and paths

On some systems:

• Readme.md
• README.md
• readme.md

may be different or conventionally significant.

Do not normalize technical paths for style.

Step 12: case in URLs

Domain names are largely case-insensitive in common use, but path components can be case-sensitive depending on server.

Do not alter URL case casually.

Treat URLs as structured identifiers.

Step 13: all caps source text

Source:

WARNING

Should target also be all caps?

Maybe.

If visual design uses uppercase warning labels, preserve the design convention.

If source author typed all caps informally but target style does not, adapt.

Case can be formatting, semantics, or noise.

Context decides.

Step 14: acronym versus word

Examples:

• US
• us

One is country abbreviation. One is pronoun in English.

Case changes meaning.

Similarly:

• IT
• it.

In multilingual target text, acronyms can collide with ordinary words.

Capitalization QA can protect distinctions.

Step 15: abbreviations that become words

Some acronyms lexicalize over time.

Project style may choose:

• NASA;
• Nasa;
• laser.

Do not assume “original acronym” means all caps forever.

Follow target-language convention and client style.

Step 16: language-specific capitalization

Different languages capitalize:

• nouns;
• days/months;
• nationalities;
• titles;
• formal pronouns

differently.

A source-target case comparison should never substitute for target-language grammar.

Capitalization QA needs locale awareness.

Step 17: Turkish dotted and dotless I

Case conversion can be language-sensitive.

Generic software case transformations may mishandle:

• I;
• İ;
• ı;
• i.

This is a classic reason not to perform language-blind uppercase/lowercase normalization.

Use locale-aware tools.

Step 18: Greek sigma and Unicode case

Some scripts have context-sensitive case behavior.

Unicode provides case mappings, but language and position can matter.

Again: automatic conversion is not linguistic review.

Step 19: German capitalization

German capitalizes nouns.

An English-source lowercase term may need uppercase in German.

A source-following capitalization rule would be wrong.

The target language generates its own case pattern.

Step 20: French and Romance-language headings

Many style guides prefer less title capitalization than English.

A translator copying English title case can create unnatural headings.

Target-only review is excellent for spotting this.

Step 21: CJK content

Chinese and Japanese do not use uppercase/lowercase across native scripts the way Latin scripts do.

But embedded:

• brands;
• acronyms;
• Latin terms

still have case.

Capitals QA may apply only to those Latin tokens.

Locale-specific profiles reduce noise.

Step 22: all-lowercase brand names

Some brands intentionally begin lowercase.

A sentence-start rule can falsely “correct” them.

Termbase should override generic capitalization expectations.

Step 23: global case conversion is dangerous

Commands such as:

• UPPERCASE;
• lowercase;
• Title Case

can destroy:

• brands;
• code;
• names;
• acronyms.

Never select an entire translated file and normalize case blindly.

Use targeted edits.

Step 24: capitalization after find-and-replace

Global terminology replacement may introduce wrong case.

Example: Replace:

account

with:

Account

Now every mid-sentence occurrence becomes capitalized.

After global replacement:

• run capitalization QA;
• search the new term;
• inspect contexts.

Step 25: capitalization after TM reuse

A TM target may come from:

• heading;
• sentence;
• button.

Same source string appears in a new context.

The target casing may be wrong.

This is one reason exact text reuse can still require context review.

Step 26: capitalization after MT

MT generally handles ordinary sentence case well.

It can still mishandle:

• brand stylization;
• product tiers;
• acronyms;
• legal defined terms.

Terminology and case QA remain valuable after MT.

Step 27: capitalization after reviewer editing

Reviewer may retype a term and lose brand case.

Run final QA after review.

Do not assume reviewer stage only removes errors.

Step 28: capitalization and spellcheck

Spellcheck may treat:

• GitHub;
• Github

as both acceptable or both unknown.

Spellcheck checks lexical validity.

Capitalization/terminology checks enforce approved form.

Different job.

Step 29: capitalization and custom dictionaries

Adding a lowercase brand variant to a custom spelling dictionary may hide a case error.

Example: approved:

AcmeCloud

translator adds:

acmecloud

to dictionary.

Spellcheck stops warning.

Case QA should still flag it if configured.

This is why resources need clear responsibilities.

Step 30: capitalization and consistency QA

Same source string may appear with:

• Save;
• save;
• SAVE

Consistency QA can show target variation.

Capitalization QA determines whether variation is allowed.

The two checks complement each other.

Failure mode 1: copy source title case into target

Result: unnatural headings.

Repair: target style guide.

Failure mode 2: lowercase brand variant accepted

Result: brand error.

Repair: case-sensitive terminology.

Failure mode 3: automatic sentence-start capitalization breaks brand

Result: iPhone → IPhone.

Repair: term exception.

Failure mode 4: global uppercase used for emphasis

Result: code/names damaged.

Repair: targeted formatting.

Failure mode 5: reviewer retypes acronym

Result: API → Api.

Repair: final case QA.

Failure mode 6: English capitalization rules applied globally

Result: locale errors.

Repair: locale-specific QA.

Failure mode 7: custom dictionary hides case defect

Result: spellcheck gives false confidence.

Repair: separate spelling from case rules.

Failure mode 8: legal defined term loses capital

Result: scope ambiguity.

Repair: defined-term governance.

Failure mode 9: URL/path case normalized

Result: technical failure.

Repair: protect identifiers.

Failure mode 10: heading case fixed without screenshot/context

Result: UI style inconsistency.

Repair: use context.

A capitalization triage table

Finding	Main question
sentence starts lowercase	grammar or brand exception?
brand case differs	exact approved form?
acronym changed	conventional target form?
heading copies source title case	target style?
legal term lowercase	defined or generic use?
code token changed case	protected identifier?
UI label case differs	component style?
personal name case differs	authoritative spelling?

A five-minute capitalization setup

Before project:

1. identify target heading style;
2. identify UI case rules;
3. import case-sensitive brand terms;
4. list acronyms;
5. test one lowercase sentence start;
6. test one lowercase brand exception.

This calibrates the checker.

A final capitalization sweep

Before delivery:

1. run capitals QA;
2. inspect brand terms;
3. inspect acronyms;
4. inspect headings;
5. inspect sentence starts;
6. inspect legal defined terms;
7. inspect technical identifiers;
8. target-only read visible headings/UI.

Build a case-sensitive terminology list

High-value entries:

• product names;
• company names;
• features;
• acronyms;
• protocol names;
• official institutions.

Do not overload it with ordinary words.

Case-sensitive QA is strongest where exact form matters.

Use regex only for stable patterns

Examples:

• product prefix must be uppercase;
• deprecated lowercase brand form forbidden;
• heading codes follow [A-Z]{3}-\d+.

Regex can extend native case checks.

But ordinary language casing belongs to target-language review.

Measure false positives

A capitals check with too many warnings becomes noise.

Common false-positive sources:

• lowercase brands;
• sentence fragments;
• code;
• UI labels;
• same-language adaptation.

Tune scope or severity.

Capitalization severity by consequence

High

• brand;
• legal defined term;
• technical identifier.

Medium

• heading;
• UI label;
• acronym.

Low

• ordinary prose style if meaning unaffected.

This helps prioritization.

Search-intent transfer

People searching:

• “capitalization QA translation”
• “uppercase lowercase CAT tool”
• “capitalization inconsistency localization”

need: case policy + automated detection + context exceptions.

They do not need a general style-guide article.

Training drill

Create target examples with:

• lowercase sentence start;
• wrong brand case;
• wrong acronym;
• English title case copied into target;
• correct lowercase brand;
• legal defined term;
• code identifier.

Classify which should change.

This teaches case as function, not decoration.

The deeper principle: case belongs to the target system

Source capitalization can indicate:

• structure;
• identity;
• emphasis.

The target must reproduce the relevant function using its own conventions.

Sometimes that means preserving exact case.

Sometimes that means changing it.

The translator’s job is not visual copying.

It is functional transfer.

Why capitalization QA improves speed

Without a case check, reviewers scan every visible word for small shape errors.

With a focused warning queue:

• brands;
• sentence starts;
• suspicious case differences

receive attention first.

Mechanical inspection becomes targeted.

Final operating model

Define target case policy → encode exact identities → run capitalization QA → classify context → correct real errors → preserve exceptions → rerun after review

Capitalization becomes a controlled layer rather than an aesthetic afterthought.

Build a capitalization matrix by content surface

A single project may contain several surfaces, each with its own case convention.

Example:

Surface	Case convention
page heading	sentence case
navigation tab	title-style product convention
button	sentence case
warning label	ALL CAPS
product feature	exact brand case
legal defined term	approved capitalized form

This matrix is more useful than a vague instruction such as:

Use correct capitalization.

It turns style into an operational rule.

Why surface-specific rules matter

Source strings can repeat across surfaces.

Source:

Account settings

Occurrence A:

• navigation heading.

Occurrence B:

• sentence fragment inside help text.

Occurrence C:

• breadcrumb.

The target may need different capitalization in each location.

A global search-and-replace cannot decide that.

String keys and screenshots help.

Build case rules into string context

If the localization format carries:

• key;
• context note;
• UI type;
• character limit;

add case guidance where useful.

Example: button.save → button, sentence case.

tab.account → navigation tab, product UI title convention.

The translator should not infer interface role from the source string alone.

Review all-caps source carefully

Source authors use ALL CAPS for many reasons:

• warning;
• design;
• shouting;
• legacy formatting;
• table heading.

The target decision should ask:

What function does all caps perform?

If it marks a formal warning label, preserve according to product style.

If it is accidental source formatting, target may normalize.

Do not convert all caps before terminology recognition

Some CAT/TMS terminology matching can be sensitive to case or token form.

If you normalize source or target case too early, glossary behavior may change.

Keep the terminology system stable first.

Then apply target style.

Case and grammatical inflection

In some languages, changing case may change how spellcheck or morphology engines interpret the token.

A brand inserted inside an inflected construction can create tension:

• brand must preserve exact case;
• grammar needs suffix or case ending.