Sentence case vs title case: Rules and examples

November 11, 2026 · 11 min read

Sentence case: What it is, with examples and a title case comparison

Sentence case is a capitalization style where you capitalize only the first word of a heading, title or label, plus any proper nouns and acronyms. Everything else stays lowercase, the way it would in an ordinary sentence. Every heading on this page uses it. Below you'll find examples, the rules major style guides set and a side-by-side with title case.

What is sentence case?

The style treats a heading as if it were a sentence. You capitalize the opening word, write names and acronyms the way they're normally spelled, and lowercase the rest. Three rules cover almost every heading you'll write:

  1. Capitalize the first word.
  2. Keep proper nouns and acronyms in their usual form: GitHub, Python, PDF, API.
  3. Lowercase everything else, including long words such as "between" and "without".

The logic comes from running text. In a paragraph, a capital letter does one of two jobs: it marks the start of a sentence or it marks a name. This style keeps capitals for exactly those jobs, so a capital mid-heading carries meaning. If "Pages" is capitalized halfway through a heading, readers know you mean Apple's app rather than pages in general.

Sentence case examples: Headings, buttons and references

The quickest way to learn the style is to see the same text both ways.

Where it appearsTitle caseSentence case
Docs headingHow to Install the CLI on WindowsHow to install the CLI on Windows
Button labelSave ChangesSave changes
Blog post titleWhy We Moved Our Docs to MarkdownWhy we moved our docs to Markdown
Error messageCouldn't Reach the ServerCouldn't reach the server
Checkbox labelEmail Me When Someone RepliesEmail me when someone replies

Notice what survives in the right column: the first word, plus CLI, Windows and Markdown. Nothing else keeps a capital.

Reference lists give a less obvious example. APA Style lowercases the titles of articles, books and webpages this way, even when the original used title case. Here's a made-up entry in that format:

Rivera, L. (2024). Writing for screens: A field guide to interface text. Journal of Interface Writing, 12(2), 45–60.

The article title follows the rule, with a capital after the colon because APA treats what follows it as a subtitle. The journal name keeps title case, as in the reference examples on APA's site.

Sentence case vs title case: The differences side by side

Title case capitalizes most words and leaves short function words such as a, of and on in lowercase. Its counterpart does the reverse and lowercases nearly everything. Here's one heading written both ways:

Title case:    How to Publish Your Docs on GitHub Pages
Sentence case: How to publish your docs on GitHub Pages

GitHub Pages keeps its capitals in both versions because it's a product name. The table below sets out the other differences.

QuestionSentence caseTitle case
Is the first word capitalized?YesYes
Nouns, verbs and adjectivesLowercase unless a proper nounCapitalized
Articles and short prepositions (a, the, of, on)LowercaseLowercase unless first or last
Proper nouns and acronymsKeep their usual formKeep their usual form
First word after a colon in a headingCapitalized under APA, Microsoft and GoogleCapitalized
Decisions per headingOne: is this word a name?Several: which small words stay low?
Typical usesDocs headings, UI labels, APA reference titlesBook and song titles, product names, journal names

For headings, the title case vs sentence case decision usually comes down to one test: are you naming a published work or a product? If so, title case still has its place. The Microsoft Writing Style Guide keeps title-style capitalization for product and service names, blog names, book and song titles, and article titles in citations. AP, APA and Chicago each draw the line on small words differently, so check your own guide for those details. Our title case rules post compares all three, plus MLA, side by side.

Which style guides use sentence case?

Several of the guides that writers and developers rely on make it the default for headings. The details differ, so here's what each one actually asks for.

APA Style. The APA sentence case page applies the style to titles of works in reference list entries, plus table column headings, table entries and notes, and figure notes. Within a title, it capitalizes the first word and the first word of a subtitle. It also capitalizes the first word after a colon, em dash or end punctuation in a heading, nouns followed by numerals or letters, and proper nouns.

Microsoft Writing Style Guide. Sentence-style capitalization is Microsoft's default. It covers titles, headings and UI labels such as button and checkbox names. Titles of blog posts, documentation articles and press releases follow it too.

Google developer documentation style guide. Google's capitalization page sets the same default for document titles and headings. Only the first word, the first word of a subheading after a colon and terms that are always capitalized get capitals.

Across all three, text that people scan, click or skim gets the plain, first-word style. Names of published works keep title case.

Sentence case capitalization rules for colons, hyphens, acronyms and names

The three basic rules don't settle every heading. These are the spots where writers hesitate and where automatic tools go wrong.

After a colon

For headings, the three guides agree: capitalize the first word after the colon. APA does it for subtitles, Microsoft does it for any title or heading containing a colon, and Google does it for a subheading after a colon. So you'd write "Markdown tables: A quick reference".

Running text is different. Google says to start lowercase after a colon in body copy, with exceptions for proper nouns, headings, quotations and text that follows a label such as Note. That's why a sentence like "There's one catch: names lose their capitals" keeps "names" lowercase.

Hyphenated words

When a hyphenated word opens a heading, Google capitalizes only its first part. That gives "Step-by-step setup" and "Built-in keyboard shortcuts". The exception is a later part that's a proper noun or adjective, as in "Non-English content".

Acronyms and initialisms

Acronyms stay in capitals wherever they fall: API, URL, PDF, HTML. Their spelled-out forms don't inherit those capitals. Microsoft's guide says not to capitalize the spelled-out form unless it's a proper noun, so API becomes "application programming interface" when you write it in full.

Names that start with a lowercase letter

Brands such as iPhone, eBay and npm break the first-word rule. Microsoft's guide says to rewrite sentences that start with a word that's always lowercase, and the same fix works for headings. Instead of "iPhone setup checklist", write "Setting up a new iPhone". Mid-heading, the brand keeps its own spelling.

Labels with numbers

APA capitalizes a noun followed by a numeral or letter, so "Results from Experiment 2" keeps its capital E. The same habit reads naturally for Table 3 or Figure 4 in technical docs.

Writing Markdown headings in sentence case

Markdown doesn't care how you capitalize a heading, so the choice is yours. Here's a short doc outline written that way:

# Deploying the docs site

## Before you start

## Connect your GitHub repository

## Add a custom domain

## Troubleshooting 404 errors

This renders as one H1 followed by four H2s. In a sidebar or table of contents, the list reads like a set of steps, and the only capitals inside it belong to GitHub. For the heading syntax itself, see our Markdown headings guide.

Our house rule: in every Markdown file, headings capitalize only the first word and names. Each heading needs one check (is this word a name?) instead of a trip to a list of small prepositions. It also scales across contributors: a new writer can match the style without reading anything first. Whatever you pick, write it into your Markdown style guide so every file follows it. Teams writing larger docs sets can find more on structure in our guide to writing docs in Markdown.

The risk with this style is a name losing its capitals. The markdownlint rule MD044 (proper-names) catches that. You give it a names list, and it flags any other casing of those words anywhere in the file:

{
  "MD044": {
    "names": ["GitHub", "JavaScript", "Markdown"],
    "code_blocks": false
  }
}

With this config, a heading such as "Set up github actions" gets flagged for "github". Setting code_blocks to false skips code spans and blocks, where lowercase names in commands and paths are correct.

How do you convert all caps to sentence case?

Our case converter handles the first pass. It runs in your browser, and browser-based tools on the site are unlimited for everyone. Its sentence style capitalizes the first letter of each sentence and line. In mixed-case text it keeps acronyms such as API and names with an inner capital such as GitHub. It still lowercases names that carry only an initial capital, such as Markdown or Google. When a whole line is in capitals, every word gets lowercased, acronyms included, so you'll restore names by hand.

Here's what that looks like with text typed in capitals:

Input:      MEETING NOTES FROM THE GITHUB API REVIEW
Converted:  Meeting notes from the github api review
Fixed:      Meeting notes from the GitHub API review

The same thing happens with title case input, where real names get lowercased along with everything else:

Input:      Writing Docs In Markdown With Google Docs
Converted:  Writing docs in markdown with google docs
Fixed:      Writing docs in Markdown with Google Docs

A case converter can't reliably tell a brand name from an ordinary word, so budget time for that hand pass on anything you publish. In a spreadsheet, a formula can change case in Excel, and our letter case converter guide covers the Word and Google Docs menus.

CSS sentence case: Why text-transform can't do it

CSS has no value for this style. According to MDN's text-transform reference, capitalize uppercases the first letter of every word, which gives you something closer to title case. MDN also points out that it isn't true title case, since it doesn't skip articles.

The common workaround lowercases the whole element, then uppercases its first letter:

.label {
  display: inline-block;
  text-transform: lowercase;
}

.label::first-letter {
  text-transform: uppercase;
}

Applied to a label containing "EXPORT TO PDF", this displays "Export to pdf". That shows the first catch: acronyms and names get lowercased along with everything else. The pseudo-element also only matches the first letter of the first line of a block container, which is why the rule sets inline-block. It won't capitalize later sentences either.

The HTML still holds the original text, because CSS only changes how it's displayed. We'd store labels with the right capitals at the source and keep this trick for text you can't edit.

Sentence case comes down to one question per word: is it the start of the heading, or a name? Answer that consistently and your headings, buttons and reference titles will match the major style guides. For a first pass on a batch of headings, run them through the case converter and restore names by hand. Then paste your outline into the Markdown editor to see how it reads in the live preview.