How to Fix Capitalization in HubSpot Properties

There's a special kind of cringe that comes from sending a personalized email that opens with "Hi JOHN" or "Hi john." It signals that your CRM data is messy and that nobody cared enough to fix it. Worse, it erodes the recipient's trust — if you can't get their name right, why should they trust your product?

Capitalization problems are one of the most visible data quality issues in HubSpot. They show up in emails, in sales outreach, in reports, and in the HubSpot UI itself. And they're surprisingly common because HubSpot stores text exactly as it arrives, with no automatic case correction.

Here is what fixing inconsistent casing looks like across a property in bulk:

How capitalization goes wrong

Form submissions. Web visitors type their name in all lowercase, all caps, or with random casing. Mobile keyboards sometimes auto-capitalize the first letter, sometimes they don't. HubSpot stores whatever comes through.

CSV imports. The source data was all caps (common in legacy databases and government records) or all lowercase (common in some marketing platforms). Nobody normalized the case before importing.

Integrations. A Salesforce sync might send names in LASTNAME, FIRSTNAME format. A Zendesk integration might pass through lowercase. Each source system has its own quirks.

Manual entry by reps. Typing in a hurry, caps lock on, autocorrect off. It happens.

API writes. Automated processes that create or update records often don't bother with case normalization. A lead capture tool might send john smith because that's what the underlying form submitted.

What "correct" looks like for different properties

Not all properties should be capitalized the same way.

Names (first, last, company): Title Case. Each word's first letter capitalized, remaining letters lowercase. "John Smith," "Acme Corporation," "McKinsey & Company." Watch out for names with special casing: "McDonald's," "iPhone," "van der Berg." You can't perfectly automate these, but you can fix the vast majority.

Email addresses: Always lowercase. Technically email local parts are case-sensitive per RFC 5321, but in practice every major email provider treats them as case-insensitive. Storing them in lowercase prevents duplicate issues and looks cleaner.

Addresses: Title Case for street names and cities. Uppercase for state abbreviations (CA, NY, TX) and country codes if you use them. Lowercase for unit designators (apt, ste, fl) — though these are often capitalized by convention too.

Job titles: Title Case, with articles and prepositions in lowercase. "Vice President of Marketing," "Director of Engineering," "Head of Product."

Custom text properties: Depends on usage. Dropdown-backed properties should already be consistent. Free-text properties need case-by-case decisions.

Finding capitalization problems

Before you fix anything, you need to know the scope of the problem. Here are search patterns that surface the most common issues:

All uppercase names: Search the first name property for ^[A-Z]{2,}$ — this matches values that are entirely uppercase letters with at least two characters. "JOHN" matches; "John" does not.

All lowercase names: Search for ^[a-z]+$ — entirely lowercase. "john" matches; "John" does not.

All uppercase company names: Same regex on the company name property: ^[A-Z\s&.,'-]+$. This pattern allows common company name punctuation.

Mixed case with no uppercase first letter: Search for ^[a-z] — values that start with a lowercase letter. This catches "john Smith" and "acme Corp."

Fixing all-caps names

ALL CAPS is the single most common casing problem, especially in portals that imported data from older systems. The fix depends on your tooling.

The straightforward approach is to target specific values you find. If you search and find 200 contacts named "JOHN," you can replace JOHN with John on the first name property. Then "MICHAEL" becomes "Michael," "SARAH" becomes "Sarah," and so on.

This is tedious if you have hundreds of unique first names in all caps. But it's safe — you see exactly what's changing.

The batched approach is more efficient. Export the affected records, fix the casing in a spreadsheet using the PROPER() function, and re-import. This handles all names in one pass. The downside is the import risk: if you map a column wrong or the PROPER function mis-capitalizes something (it would turn "O'BRIEN" into "O'Brien," which is correct, but "MCDONALD" becomes "Mcdonald" instead of "McDonald"), you've introduced new errors.

Using SearchReplace, you can work through the most common all-caps names efficiently. Search the first name property for each common name in uppercase and replace it with the properly cased version. Because first names follow power-law distributions — the top 100 names cover a huge percentage of your database — you can fix the majority with a manageable number of operations.

For each operation, you get a preview showing every affected record. This catches edge cases: maybe "GRACE" in all caps is actually a company name that got mapped to the wrong field, or "APRIL" is a month reference from a bad import. The preview lets you catch these before applying.

Fixing all-lowercase values

Lowercase names are typically easier because the same search-and-replace works: find john, replace with John. The volume is usually lower than all-caps problems.

For company names in lowercase, be more careful. Some company names are intentionally lowercase — "adidas," "lululemon," "eBay." A blanket title-case conversion would incorrectly capitalize these. Check your preview before applying.

Fixing email addresses

Email case is simpler: everything should be lowercase. Search your email property for [A-Z] to find any addresses with uppercase characters. Then replace with the lowercase version.

If your tool supports case-insensitive replacement with lowercase output, one operation handles it all. Otherwise, you may need to work through common patterns: @Gmail.com to @gmail.com, @COMPANY.COM to @company.com, etc.

The property-by-property approach

Rather than trying to fix all capitalization everywhere at once, work through properties in priority order:

1. First name — highest visibility, used in email personalization
2. Last name — same reason
3. Email — affects deduplication and deliverability tracking
4. Company name — appears in reports and account-based views
5. Job title — used in segmentation and lead scoring
6. City — appears in address blocks and regional reports
7. Other text properties — based on your usage

For each property, run the all-caps search first (highest volume), then the all-lowercase search, then spot-check for mixed-case oddities.

Handling edge cases

Some names and values resist simple Title Case rules.

Names with prefixes: McDonald, McBride, MacArthur, O'Brien, O'Connell. A simple PROPER() function gets these wrong. You'll need specific replacements: Mcdonald to McDonald, Obrien to O'Brien.

Hyphenated names: "Anne-Marie," "Jean-Pierre." Title Case should capitalize both parts.

Particles: "van der Berg," "de la Cruz," "von Trapp." Convention varies by culture — Dutch "van" is lowercase, German "von" is lowercase, but when used without a first name, they're sometimes capitalized. This is a judgment call. Pick a convention and apply it consistently.

Acronyms in company names: "IBM," "SAP," "BMW" should stay uppercase. "ACME Corporation" should have "ACME" stay uppercase if that's the brand style. Review your preview carefully for companies before applying blanket case changes.

Intentionally styled names: "iPhone," "eBay," "WordPress." These have specific casing that Title Case would break. You'll need to handle these individually.

Preventing future casing issues

Set up HubSpot Data Hub formatting. If you have HubSpot Data Hub (formerly Operations Hub) Professional or Enterprise, you can use data quality automation to automatically format names in Title Case when a contact is created or updated. This is the gold standard for prevention.

Validate form inputs. While you can't force casing on HubSpot forms natively, you can add custom JavaScript to your forms that auto-capitalizes name fields on submission. This catches the issue at the point of entry.

Clean imports before uploading. Make it a rule: every CSV import gets a casing pass before upload. PROPER() in Google Sheets or Excel handles 90% of cases.

Document your standards. Add property descriptions in HubSpot that specify the expected casing. "Use Title Case: John Smith, not JOHN SMITH or john smith."

Capitalization is one of those problems that seems trivial until a CEO gets an email that opens with "Hi MIKE" from your sales team. It takes a focused afternoon to fix and five minutes of diligence per import to prevent. The return on that investment shows up in every email, every report, and every interaction where your data faces the outside world.