If you’re building beautifully designed emails and landing pages in HubSpot but still dealing with underwhelming engagement metrics, you’re not alone. A major reason so many campaigns fall flat? They read like boilerplate. When every recipient sees the same generic copy, even a well-crafted message can feel irrelevant or disconnected—and that hurts your conversions and your brand.
HubSpot offers tools that let you personalize messaging at scale, and personalization tokens are among the most powerful. These tokens automatically pull CRM data—like contact names, company info, or deal details—into your templates and modules so every experience feels tailored to the individual.
But here’s the catch: many Marketing Ops and RevOps teams don’t fully tap into personalization when working within HubSpot’s Design Manager. Templated assets often stay static simply because the underlying logic for dynamic content isn’t well implemented.
This guide walks you through how personalization tokens work technically inside the Design Manager. You’ll see exactly where to find them, how to configure fallback logic, and how to evaluate your results—with steps tied directly to HubSpot’s menus so you can follow along in your own portal.
Implementing CRM Personalization Tokens in Code
Personalization tokens are dynamic placeholders that automatically pull CRM details into your marketing assets. When someone views that content—be it an email, web page, or even an internal notification—HubSpot replaces the token with live data specific to that individual or company.
Inside the Design Manager, personalization becomes more advanced. Here, these tokens are embedded directly within modules or templates using HubL, HubSpot’s own markup language. This lets developers and template designers set up layouts that adjust dynamically without requiring ongoing manual input for each email or page.
Tokens work across various CRM objects—contacts, companies, deals, tickets, even custom objects—so long as those fields are populated. If there’s no matching data, HubSpot inserts the fallback text you’ve specified in the code. That level of automation allows you to scale personalized marketing without ever touching the content post-launch.
It’s important to distinguish this from the standard “personalize” button you might use while writing an email in the content editor. That feature works on a one-off basis. In contrast, using tokens at the template level gives you a reusable, CMS-level personalization structure that applies reliably across multiple campaigns and touchpoints.
How It Works Under the Hood
Behind the scenes, each personalization token uses HubL syntax. HubL tells HubSpot what data to pull and where to insert it during content rendering. For example, {{ contact.firstname }} pulls the first name from the contact record tied to the current email or page view.
Here’s the simplified workflow:
- Input: CRM data already stored in contact, company, deal, or ticket records.
- Processing: When the content is rendered or sent, HubSpot identifies the recipient or visitor and fetches relevant values.
- Output: The token is replaced with actual text pulled from the applicable CRM field.
When those records are incomplete, fallback values become essential. If you forget to set them, you’re left with empty or broken-looking text like “Hi ,” in your emails.
To prevent that, you can include fallback defaults using syntax like:
{{ contact.firstname|default(’there’) }}
This ensures you always have a clear, polished message—whether or not the data field is filled.
Keep in mind, personalization tokens only work when HubSpot can identify the end user. That means they’ll resolve in emails (because each email is tied to a known contact), or on web pages where a visitor has been cooked and matched to a CRM record. Anonymous users won’t see personalized fields unless you layer in smart content or other contextualization methods.
Main Uses Inside HubSpot
Personalized Email Templates
You can dramatically improve email relevance by baking personalization directly into your templates. In Design Manager, email modules are structured with HTML and HubL, giving you full control over token placement within greetings, subject lines, CTAs, and more.
For example: In your email header module, use {{ contact.firstname|default(’there’) }} to generate a personalized salutation like “Hi Sarah.” When your email is sent via workflow, HubSpot pulls and secures the right data in real time.
This minimal adjustment goes a long way toward making your outreach feel thoughtful rather than canned.
Dynamic Landing Page Content
Landing pages can also flex depending on who’s viewing them—if you’ve set up personalization correctly. In Design Manager, you can inject tokens into key areas like headlines, body copy, or testimonials.
Let’s say you offer a SaaS solution across multiple industries. Adding {{ company.industry|default(’your industry’) }} to your hero section can immediately reflect the visitor’s context, showing something like “Solutions for Healthcare Providers” instead of a vague catch-all.
This turns one general-purpose landing page into a personalized experience for multiple audience segments—all without duplicating assets.
Smart Website Modules or CTAs
When you pair personalization tokens with HubSpot’s smart content features, you unlock a high level of customization from a single module.
Imagine a homepage module coded with: Welcome back, {{ contact.firstname|default(’visitor’) }}
Then layered with smart rules based on lifecycle stage, so leads and customers see different messages or CTAs. Design Manager lets you house both logic layers—tokens and smart module rules—within one file, simplifying your asset library without sacrificing relevance.
This combo enables teams to personalize broadly while staying operationally efficient.
CRM-Driven Internal Templates
Personalization tokens aren’t just for marketing assets. You can apply the same logic to internal workflows—like sending ticket updates to service reps or quote notifications to sales.
For instance, an internal email triggered by a support ticket might include:
Subject: Follow-up on {{ ticket.subject }}
Body: Hello {{ contact.firstname }}, thanks for your recent support request.
These templates are built in Design Manager so they update dynamically for each internal recipient. That reduces manual input and ensures consistency across service communications.
Common Setup Errors and Wrong Assumptions
- Not testing fallback values: Failing to build in fallbacks often leads to visible formatting flaws like “Hi ,” or blank CTAs. Always include |default(’text’) in your syntax to account for missing fields.
- Mixing contact and company tokens incorrectly: Be cautious when pulling from company fields in a contact-based email. If the contact isn’t associated with a company in the CRM, the token won’t populate. Keep token types aligned with the sending object’s context.
- Expecting tokens to resolve for anonymous visitors: Personalization tokens require a known record (email recipient or cookie-identified website visitor). If there’s no identity match, tokens won’t display. For anonymous visitors, use smart content instead.
- Hardcoding tokens with invalid syntax: If you skip the required {{ }} brackets or miswrite HubL syntax, your token outputs as plain text instead of dynamic content. Always verify coding standards in HubSpot’s HubL documentation.
Step-by-Step Setup or Use Guide
Before diving in, confirm two things: you have edit permissions for the Design Manager, and your CRM fields (like firstname, company.name) contain usable data for your intended audience.
- Open the Design Manager.
Head to the Settings gear > Tools > Design Manager—or go directly through Marketing > Files and Templates > Design Tools.
- Select or create a template.
Use an existing coded template or create a fresh one. The left sidebar lets you browse modules and asset files.
- Insert a personalization token.
In any text or HTML module, enter the HubL syntax. For example: {{ contact.firstname|default(’there’) }}.
- Add fallback text where needed.
Never skip the fallback. If the property isn’t filled in the CRM, fallback text ensures your messaging stays clean.
- Save and publish changes.
Click “Publish changes” to apply the updates across your template library.
- Test in email or page preview.
Use “Preview as specific contact” to make sure the tokens pull correctly. Check spacing and test various fallback cases.
- Use in campaigns or workflows.
Embed your finalized templates within HubSpot emails, landing pages, or workflows. Ensure only the right records trigger your content.
- Monitor rendering through test sends.
Send test emails to real contacts or sandbox users to confirm tokens render exactly as expected before launching broader campaigns.
With these steps, you can confidently personalize content automatically—without repetitive manual updates or fragmented templates.
Measuring Results in HubSpot
Once your personalization is in place, you need to measure whether it’s working. HubSpot provides several built-in tools to help you track performance and justify your strategy.
Here’s a checklist to guide your review:
- Email metrics: Use HubSpot’s Email Reports to compare open and click rates between personalized versus static versions.
- Landing page performance: Evaluate conversion rates, bounce rates, and form submissions across personalized versus control versions.
- Smart module analytics: Analyze views, clicks, and variant performance from the Smart Content tab in reporting.
- Contact property monitoring: Track how many CRM records now include data you’re relying on for personalization—gaps here can flag cleanup needs.
- Custom dashboards: Build visual reports segmented by lifecycle stage or contact list to assess message impact by persona or funnel stage.
Improved performance from tokens often shows up in metrics like reduced unsubscribe rates, longer time on page, and higher clickthroughs—all signals that your audience feels more directly spoken to.
Short Example That Ties It Together
Let’s say you’re in charge of nurturing leads in a B2B funnel. Rather than sending a generic email, you want each message to greet recipients by name and mention their company.
In the Design Manager, your team creates a coded email template. Inside a header module, you include both:
- {{ contact.firstname|default(’there’) }}
- {{ company.name|default(’your business’) }}
When this message goes out to Sarah Lopez from Greenbyte Software, HubSpot renders:
“Hi, Sarah from Greenbyte Software.”
If no company record exists, it becomes:
“Hi there from your business.”
Later, you review HubSpot’s campaign analytics. Personalized emails achieve a 17% higher click-through rate and fewer unsubscribes than control-group emails. For your team, that’s proof that token configuration worked—and delivered results.
How INSIDEA Helps
Getting personalization right in HubSpot isn’t just about knowing how to code tokens—it’s about aligning your CRM, templates, and workflows into one seamless strategy. That’s where INSIDEA comes in.
We work with HubSpot teams to plan and execute personalization from the ground up, ensuring everything from design structure to data hygiene supports your performance goals.
Here’s how INSIDEA supports you:
- HubSpot onboarding: Lay the foundation with CRM-aligned templates and token-ready Design Manager structures.
- HubSpot management: Keep your system tidy—from organized file storage to maintaining dynamic assets across global teams.
- Automation support: Build lifecycle workflows enhanced with personalized content blocks and smart delivery triggers.
- Reporting alignment: Tie personalization efforts to real metrics within custom dashboards so marketing can see exactly what’s working.
Visit INSIDEA to explore how our HubSpot experts can help you personalize at scale—without compromising accuracy or speed. Also, check out HubSpot consulting services.
