firstName or first_name? The Naming Convention Guide That Ends the Debate

It usually happens around the third week of a new project. Someone opens a pull request, and buried in the review comments is a thread that somehow lasts longer than the actual feature discussion: 'We're using camelCase for variables.' 'But Python convention is snake_case.' 'Can we just pick one?' I've seen this go twenty comments deep. This guide is what should have been linked instead.

The Six Case Formats, Defined

There are more naming conventions than most people realize. The common ones have names that describe their appearance, but what matters is understanding exactly when each is expected — not just in one language, but across the whole stack.

Language-by-Language: What the Community Actually Does

The frustrating thing about naming conventions is that they're not universal. What's correct in JavaScript is wrong in Python. What's idiomatic in CSS looks broken in SQL. Here's a quick reference that covers the main ecosystems:

// JavaScript / TypeScript
const firstName = 'Alice';          // camelCase — variables
class UserProfile { }               // PascalCase — classes
const MAX_RETRIES = 3;              // SCREAMING_SNAKE — constants
type ApiResponse = { ... };         // PascalCase — types and interfaces

# Python
first_name = 'Alice'               # snake_case — variables and functions
class UserProfile:                  # PascalCase — classes
MAX_RETRIES = 3                    # SCREAMING_SNAKE — module-level constants

/* CSS */
.user-profile { }                  /* kebab-case — class names */
--primary-color: #3B82F6;          /* kebab-case — custom properties */

-- SQL
CREATE TABLE user_profiles (        -- snake_case — table names
  first_name VARCHAR(50),           -- snake_case — column names
  PRIMARY KEY (id)
);

// Go
func GetUserProfile() { }           // PascalCase — exported
func getUserProfile() { }           // camelCase — unexported

The API Naming Problem (and the Best Solution)

APIs are where naming convention debates get genuinely complicated, because your backend and frontend might use different languages. A Python Django backend naturally uses snake_case. A JavaScript React frontend expects camelCase. When you define your API response, which wins?

The industry has basically split into two camps. The JSON:API and OpenAPI communities tend to favor camelCase for JSON keys, arguing it's more natural for JavaScript consumers. Python and Ruby developers often push for snake_case because it matches their backend models directly. GraphQL schemas almost always use camelCase for field names.

• REST APIs: No universal standard, but camelCase has broader adoption across frontend-heavy teams. snake_case is common in Python and Ruby-backed APIs.
• GraphQL: camelCase for field names is near-universal (firstName, not first_name)
• gRPC / Protocol Buffers: snake_case in .proto files, camelCase generated in JS output
• Database to API mapping: Use a serialization layer (like Pydantic's alias_generator) to translate snake_case DB columns to camelCase JSON keys automatically
• Environment variables: Always SCREAMING_SNAKE_CASE — this is universal and enforced by most platforms

SEO and Title Case: More Nuanced Than You Think

For content writers and marketing teams, the main battleground is Title Case vs. Sentence case for headings and page titles. Title Case capitalizes the first letter of most words (with exceptions for articles and prepositions under 4 letters). Sentence case only capitalizes the first word and proper nouns.

The SEO implications are real but often misunderstood. Google reads and ranks both equally well — the difference is entirely about brand voice and UX. Title Case signals authority and formality (common in journalism and legal writing). Sentence case feels more conversational and modern (Google, Apple, Notion, and Linear all use it in their interfaces). The key is choosing one and being consistent across your entire site.

• Title Case: 'How to Calculate Compound Interest in Python' — formal, editorial
• Sentence case: 'How to calculate compound interest in Python' — modern, conversational
• ALL CAPS in titles: Avoid — it reads as shouting and scores poorly in user testing
• kebab-case for URL slugs: Always — spaces become %20, hyphens are human-readable and preferred by Google
• PascalCase in filenames: Common in JavaScript/React projects for component files (UserProfile.tsx)

Converting Between Cases: Faster Than You Think

Manual conversion between cases is the kind of task that sounds simple but gets tedious fast — especially when you have 50 column names from a database schema that need to become camelCase JSON keys. The algorithm is always the same: split on delimiters (spaces, underscores, hyphens, capital letters), then reassemble in the target format. A good converter tool handles all of this instantly.