Title Case vs Sentence Case: The Rules Nobody Taught You (With Examples)

This is one of those things that seems obvious until someone actually asks you to explain the rules. Then you realize you’ve been guessing this whole time.

Title case or sentence case? When do you capitalize every word? When do you capitalize just the first one? And why do APA and AP style have completely different opinions about it?

Let’s untangle this. No jargon, no fluff.

Title Case: What It Actually Means

Title case means you capitalize the first letter of “major” words in a heading. Like this:

“How to Write Better Headlines for Your Blog”

See how “to” and “for” stayed lowercase? That’s because title case has this whole system of which words count as “major” and which ones are too small to bother capitalizing.

The general rule that most people learn: capitalize everything except little words like “a,” “an,” “the,” “and,” “but,” “or,” “in,” “on,” “at,” and “to.”

But. (And this is the part that makes people want to throw their style guide out the window.) Different style guides disagree on what counts as a “little word.”

Sentence Case: What It Actually Means

Sentence case is simpler. You capitalize the first word and any proper nouns. Everything else stays lowercase. Like a normal sentence.

“How to write better headlines for your blog”

That’s it. First word gets capitalized. Proper nouns (names, places, brands) get capitalized. Everything else stays lowercase. Done.

This is why sentence case has gotten way more popular in the last decade. It’s nearly impossible to mess up.

The Big Three Style Guides (And Why They Disagree)

Here’s where things get spicy. The three most commonly used English style guides can’t agree on title case rules. Let’s break them down.

APA Style (7th Edition)

APA (American Psychological Association) is what most academic papers use. Their title case rules:

Capitalize:

• First word of the title
• First word after a colon or em dash
• All “major words” (nouns, verbs, adjectives, adverbs, pronouns)
• Words of four or more letters (this is the unique APA twist)

Don’t capitalize:

• Short conjunctions (and, as, but, for, if, nor, or, so, yet) unless they’re four letters or more
• Short prepositions (at, by, in, of, on, to, up)
• Articles (a, an, the)

APA example: “Effects of Sleep Deprivation on Cognitive Performance in College Students”

The sneaky part: APA capitalizes words of four or more letters even if they’re prepositions. So “With” gets capitalized but “with” in AP style might not. “Between” always gets capitalized. “From” always gets capitalized.

And here’s what trips up every college student: APA uses title case for your own paper’s title, but sentence case for article and book titles in your reference list. The same style guide uses both systems. In the same paper.

AP Style (Associated Press)

AP style is what journalists and most news organizations use. Their rules:

Capitalize:

• First and last word (always)
• All words with four or more letters
• Both words in a hyphenated compound (e.g., “Self-Report” not “Self-report”)
• Verbs and verb forms, including short ones like “Is,” “Be,” “Are”

Don’t capitalize:

• Articles (a, an, the)
• Prepositions of three or fewer letters (at, by, in, for, of, on, to, up)
• Coordinating conjunctions of three or fewer letters (and, but, for, nor, or, so)

AP example: “City Council Votes to Approve New Budget for School District”

AP and APA agree on most things but have subtle differences around hyphenated words, prepositions in phrasal verbs (like “Logging In” vs “Logging in”), and some edge cases that will absolutely ruin your afternoon if you go down that rabbit hole.

Chicago Manual of Style (18th Edition)

Chicago style is what book publishers, literary magazines, and many humanities departments use. It has arguably the most detailed title case rules:

Capitalize:

• First and last word (always)
• All major words (nouns, pronouns, verbs, adjectives, adverbs)
• Subordinating conjunctions (because, although, since, when, if)
• Prepositions used as adverbs or adjectives (“the ON switch”)

Don’t capitalize:

• Articles (a, an, the) unless first or last
• Coordinating conjunctions (and, but, or, nor, for, yet, so)
• Prepositions (regardless of length, with some exceptions)
• “To” in infinitives

Chicago example: “The Effects of Climate Change on Biodiversity in the Amazon”

The big Chicago difference: they don’t use the “four or more letters” shortcut. A preposition stays lowercase even if it’s long. “Between” and “throughout” stay lowercase in Chicago style (but get capitalized in APA and AP). This creates real disagreements for the same exact title.

Which One Should You Use?

Here’s the practical answer:

Academic writing? Use whatever your institution requires. That’s usually APA for sciences and social sciences, Chicago for humanities. Don’t guess. Check.

News and journalism? AP style. Always.

Blog posts and marketing? It honestly doesn’t matter that much as long as you’re consistent. Most marketing teams use a simplified version of title case (capitalize the “important” words) and nobody sends angry emails about it.

Tech and software? The trend has moved heavily toward sentence case. Apple, Google, Microsoft, and most SaaS companies switched to sentence case for UI labels, buttons, and headings years ago. It reads cleaner and translates better into other languages.

Social media? Sentence case. Title case on Twitter/X looks like you’re writing a newspaper headline from 1997.

The Internationalization Problem Nobody Mentions

Here’s something most articles about this topic skip entirely: title case is basically an English language thing. And it doesn’t translate well.

German capitalizes all nouns, not just proper nouns. German title case would be… just normal German? Their capitalization rules are baked into the grammar.

French has its own title capitalization tradition but it’s different from English. Generally only the first word and proper nouns get capitalized in French titles, with some exceptions for initial articles.

Spanish uses sentence case for virtually all titles. “Cien años de soledad” not “Cien Años de Soledad.”

Arabic doesn’t have uppercase and lowercase letters at all. The entire concept of “case” doesn’t apply.

So if you’re writing for an international audience or maintaining a multilingual website, sentence case is almost always the safer choice. It works across languages without creating weird capitalization problems in translation.

Real World Examples Side by Side

Let me show you the same title in each style so you can see the differences:

Notice the “with” in the Chicago version. Chicago doesn’t capitalize prepositions regardless of length. APA and AP capitalize “With” because it’s four letters. This one word is the source of approximately 40% of all capitalization arguments on the internet. (That statistic is made up, but it feels true.)

Another example where the differences are more dramatic:

“Through” stays lowercase in Chicago (it’s a preposition) but capitalized in APA/AP (four or more letters). “Up” could go either way depending on whether it’s acting as an adverb or preposition. This is why people end up on grammar forums at 2 AM.

Edge Cases That Actually Come Up

Phrasal verbs. “Log In” or “Log in”? When “in” is part of a phrasal verb (not a preposition), most styles capitalize it. So “How to Log In to Your Account” is correct in title case.

Hyphenated words. “Real-Time” or “Real-time”? AP capitalizes both parts. Chicago capitalizes the second part only if it’s a “major” word. APA capitalizes words of four or more letters in hyphenated compounds.

After a colon. “CSS Grid: a Complete Guide” or “CSS Grid: A Complete Guide”? Most styles capitalize the first word after a colon in a title. APA and Chicago both do this. AP is less explicit but generally follows the same pattern.

Short verbs. “Is,” “am,” “be,” “do,” “go” are all short but they’re verbs. Every style guide capitalizes them in title case. This trips people up because they think short words always stay lowercase. Nope. Verbs always get capitalized regardless of length.

Just Convert It Automatically

Look, if you’re not writing an academic paper where your professor will dock points for wrong capitalization, the easiest approach is to just use a tool.

TextSorter’s Case Converter handles Title Case, Sentence case, UPPERCASE, lowercase, camelCase, PascalCase, snake_case, and kebab-case. Paste your text, click the format you want, copy the result. It runs in your browser, nothing gets sent anywhere, no signup.

For academic papers where the style guide matters, use the converter for a first pass and then manually check the edge cases (phrasal verbs, hyphenated words, words after colons). It’ll still save you time and catch the obvious stuff.

Quick Reference Cheat Sheet

Use title case when:

• Writing academic paper titles (check your required style guide)
• Creating formal report headings
• Writing book titles and chapter headings
• Formatting newspaper headlines

Use sentence case when:

• Writing UI labels and button text (industry standard since ~2020)
• Writing blog post titles (modern convention)
• Writing email subject lines
• Writing social media posts
• Anything that should feel conversational

Always capitalize (in both cases):

• First word
• Proper nouns (names, places, brands, acronyms)

Never capitalize (in title case), unless first/last word:

• “a,” “an,” “the”
• “and,” “but,” “or,” “nor,” “so,” “yet”
• “at,” “by,” “in,” “of,” “on,” “to” (varies by style for longer prepositions)

The honest truth? Pick a style and stick with it across your whole document or website. Consistency matters more than which specific rules you follow. Nobody will notice if you capitalize “With” or not. They will notice if you do it differently in every heading.

Convert your text to any case format →

In-Depth Architectural Guide: How Modern Text Processing Engines Work Under the Hood

When manipulating text, formatting strings, or extracting tokens in web applications, understanding how the underlying runtime engine processes character streams is essential for building scalable software.

In modern JavaScript engines (such as Google V8, Apple JavaScriptCore, and Mozilla SpiderMonkey), strings are stored in optimized memory structures:

+---------------------+-------------------+-------------------------------+-------------------------+
| String Representation| Memory Structure  | Performance Advantage         | Typical Use Case        |
+---------------------+-------------------+-------------------------------+-------------------------+
| Flat ASCII String   | 1 Byte / Char     | Ultra-low memory cache density| Standard English text   |
| Two-Byte UTF-16     | 2 Bytes / Char    | Universal Unicode code points | International & Emojis  |
| ConsString          | Tree of 2 strings | O(1) Instant Concatenation    | Repeated string joins   |
| SlicedString        | Pointer + Offset  | O(1) Zero-Copy Substrings     | Parsing large payloads  |
+---------------------+-------------------+-------------------------------+-------------------------+

1. The ConsString Concatenation Optimization

When you join strings repeatedly in a loop (str += chunk), V8 does not immediately copy all bytes into a new flat array. Instead, it creates a ConsString (a lightweight binary tree node referencing the two parent strings). Only when you perform a search, regex match, or export does the engine flatten the tree into contiguous memory.

2. SlicedString: High-Speed Substring Extraction

When extracting tokens or substrings from a 10-megabyte text document using str.slice(start, end), V8 creates a SlicedString containing a memory pointer to the original parent string and the start/end integer offsets. This enables instant substring extraction with zero memory allocation.

Common Pitfalls and Edge Cases in Text Manipulation

1. Surrogate Pair Truncation: When slicing strings containing multi-byte characters or emojis (🚀, 👩‍💻), naive character slicing can sever surrogate pairs, creating corrupted replacement characters (“). Always use Unicode-aware iteration (Array.from(str) or [...str]).
2. Regex Catastrophic Backtracking: Writing poorly bounded regular expressions with nested quantifiers (like (a+)+$) on untrusted user input can cause exponential CPU backtracking, locking up server worker threads. Always set strict input size limits or use atomic lookahead assertions.
3. Memory Leaks in Closures: Retaining small SlicedString tokens extracted from gigantic parent strings inside long-lived closures prevents the entire multi-megabyte parent string from being garbage collected. Always flatten or copy retained tokens.

Step-by-Step Practical Tutorial: Building High-Performance Client-Side Utilities

Here is a production-ready JavaScript class demonstrating efficient text transformations with zero external npm dependencies:

class HighPerformanceTextProcessor {
  constructor(rawText = '') {
    this.text = rawText;
  }

  cleanWhitespace() {
    this.text = this.text
      .replace(/[\r\n]+/g, '\n')
      .replace(/[^\S\r\n]+/g, ' ')
      .trim();
    return this;
  }

  deduplicateLines(caseSensitive = false) {
    const lines = this.text.split('\n');
    const seen = new Set();
    const unique = [];

    for (let i = 0; i < lines.length; i++) {
      const line = lines[i];
      const key = caseSensitive ? line : line.toLowerCase();
      if (!seen.has(key)) {
        seen.add(key);
        unique.push(line);
      }
    }
    this.text = unique.join('\n');
    return this;
  }

  getWordCount() {
    if (!this.text.trim()) return 0;
    return this.text.trim().split(/\s+/).length;
  }

  toString() {
    return this.text;
  }
}

Interactive Frequently Asked Questions (FAQ)

1. Why are 100% client-side text tools safer for sensitive corporate data?

Because traditional online text tools send your pasted text over public HTTP connections to remote cloud servers where it can be logged in databases, cached on proxies, or exposed in server logs. TextSorter executes all transformations entirely inside your local browser memory (RAM), guaranteeing that sensitive customer data, API keys, and private documents never leave your physical device.

2. Can I use these text utilities when working offline without internet access?

Yes! TextSorter is an installable Progressive Web App (PWA). Once loaded, the Service Worker caches all scripts and Web Workers locally on your machine, allowing you to clean, sort, format, and convert text on airplanes, trains, or secure offline environments.

3. How do Web Workers prevent browser UI tabs from freezing during large operations?

JavaScript is single-threaded on the main DOM thread. When processing large datasets with hundreds of thousands of rows, executing number-crunching loops on the main thread blocks UI rendering. Web Workers execute tasks in isolated background threads, keeping the browser UI completely smooth and responsive at 60 frames per second.

Summary Checklist for Clean Production Text Operations

1. Verify UTF-8 Encoding: Ensure your application specifies UTF-8 encoding across HTML, database collations, and HTTP response headers.
2. Handle Special Characters: Use standard entity encodings or parameterized queries to prevent injection vulnerabilities.
3. Audit Performance: Use Web Workers for datasets exceeding 50,000 rows to maintain silky-smooth UI responsiveness.
4. Use Privacy-First Tools: Process confidential files using TextSorter Tools. Everything runs 100% locally in your browser memory for total confidentiality.