User Journey Mapping Template: A Free Template and Guide

Copy a user journey mapping template built for signups, with filled-in examples for search, ad and newsletter visitors and steps to turn it into page copy.

Published on 14 min read
Table of contents

Most teams build a journey map the same way. They open a whiteboard, line up stages across the top, add sticky notes for actions and emotions, present the result, and then leave it in a folder. The website still greets every visitor with the same headline and the same button. The map was accurate about the visitor and silent about the page.

So what should a user journey mapping template contain if the map has to end in page changes that increase signups? What does a filled-in one look like? And how do you know the map is right once it is done?

A signup-focused template keeps the standard columns (persona, scope, stages, actions, emotions, pain points, opportunities) and adds five more: the visitor's entry point, the question in their head, what they need to hear, the page message and the CTA. A sixth, the signal you will check, turns each row into a testable hypothesis. The template is below, followed by how to fill it in, three worked examples and the mistakes to avoid.

The Signup-Focused User Journey Mapping Template

This user journey mapping template has a header block and two tables. The first table describes the visitor. The second turns each stage into copy. Copy all three into Miro, FigJam, a spreadsheet or a document, and fill in one set per persona.

Header block

FieldWhat to write
PersonaOne visitor type: role, situation, the problem that brought them
ScopeFrom first arrival to confirmed signup (or to first use, if you map retention)
GoalOne action: the signup
StateCurrent state (what the page says today) or future state (what it should say)

Table A: the visitor side

StageVisitor actionThoughts and emotionsPain point
AwarenessWhat they searched, clicked or read before arrivingWhat they believe about the problemWhat made them look
ConsiderationWhat they read and scan on the pageWhat they are comparing you againstWhat is unclear or missing
DecisionWhat they check before committing (proof, price, effort)What makes them hesitateWhat they doubt
SignupWhat they do on the form or buttonWhat they expect to happen nextWhat adds friction
After signupFirst actions in the productWhether they feel the promise was keptWhere they stall

Table B: the page side

StageEntry pointQuestion in the visitor's headWhat they need to hearPage messageCTASignal to check
AwarenessWhere they came fromWhat they want answeredOne sentence of reassuranceHeadline that continues their last clickPrimary actionEvidence it worked
Consideration
Decision
Signup
After signup

Two things make this different from a diagram. Every stage ends in words you can paste into the page. And every row names the signal that tells you whether those words worked.

The same template serves two purposes. Fill it in with what your page says today and you have a current-state map. Revise the page message and CTA columns after you make changes and you have a future-state map. Section six covers how to compare the two.

Where to build the template: You can build the template in any tool that supports tables or boards. Pick by who edits the page, not by which tool looks best.

  • Miro and Mural: Whiteboards for team workshops. Miro publishes a user journey mapping template you can adapt by adding the page-side columns.
  • Figma and FigJam: Good when designers own the page. Figma's community has a user journey map template to start from.
  • Canva: Suits slide-style maps for presenting to stakeholders, but is awkward for editing rows over time.
  • Confluence: Plain documentation. Atlassian offers a journey map template for Confluence that works if your team lives in wiki pages.
  • A spreadsheet: Often the best fit for Table B, because copy and CTAs are text and you will edit them often.

Practical rule: Store the map wherever the person who edits the page already works, or it will not be read again.

What Is a User Journey Map, and Why Do Most Templates Stop Short?

A user journey map is a visual record of the steps a person takes with a product, brand or service over time, including what they think and feel at each step. It shows the experience from the visitor's side so a team can find where it breaks.

That is where most templates stop. They capture actions, emotions and pain points, then end with an "opportunities" column holding vague ideas such as "simplify onboarding" or "build trust." Nobody can paste "build trust" into a headline. The map describes the visitor well and leaves the writer with nothing to write.

A journey map isn't a deliverable. It's a set of decisions about what each visitor should read next. Judge a map by whether it changes a headline, a paragraph or a button. If it changes none, it is a diagram, however thorough.

If you want the general method and its history, the blog's guide to user journey mapping covers it. This article stays on the signup page.

What are the 5 stages of a customer journey? The five stages of a customer journey are awareness, consideration, decision, purchase or signup, and retention. Awareness is when the visitor learns the problem exists. Consideration is comparing options. Decision is choosing one. Signup is the conversion. Retention is what happens after.

Not all five happen on your page, and that matters for how you build the map:

  • Awareness: Happens before the page. You do not control it, but it determines the entry point and the first thing the visitor expects to see.
  • Consideration: Starts on the page. The visitor scans the headline and decides whether to keep reading.
  • Decision: On the page. The visitor looks for proof, price clarity and a sense of effort.
  • Signup: On the page. The form, the button and the sentence around it.
  • Retention: After the page. Keep one row for it so the signup promise is checked against first use, but do not expand it.

Keep five rows at most. A map with twelve stages cannot be acted on, because no one will write twelve messages. If two stages would get the same page message, merge them.

What Columns Does the User Journey Mapping Template Need?

The template needs twelve fields in three groups: header fields that fix the scope, columns that describe the visitor, and columns that turn each stage into page copy. Fill the header first, then Table A, then Table B, always from left to right.

Which columns describe the visitor? These columns are the standard ones, and you should keep them short.

  • Persona: Pick one visitor type, such as "an operations lead at a small company who searched for a fix to a specific problem." Two personas need two maps.
  • Scope and goal: One journey, one goal. For this template the goal is the signup. Mapping "the whole customer experience" produces a map no page can use.
  • Visitor action: What they do, in observable terms: searched, clicked an ad, opened an email, scrolled, hovered over pricing, abandoned the form.
  • Thoughts and emotions: One sentence in the visitor's voice, such as "Is this the same thing I just read about?" Skip emotion graphs unless your team likes them.
  • Pain points: Friction, confusion or doubt. Limit it to one or two per stage.
  • Opportunities: In this template the opportunity is not a separate brainstorm. It is the page message column, so you cannot leave it vague.

Which columns turn the map into page changes? Five columns do the translation work. Common templates lack them.

  • Entry point: Where the visitor came from: a search result, a paid ad, a newsletter link, a referral. Entry point sets expectations before the page loads, so it changes what the first headline must do.
  • Question in the visitor's head: The thing they would ask if someone were beside them. "Can this solve my problem?" is different from "Is this the thing the ad promised?"
  • What they need to hear: The shortest honest answer to that question, written as a sentence a person would say.
  • Page message and CTA: The headline, supporting line and button text that deliver the answer. Write the actual words. The CTA button examples article is useful for wording options.
  • Signal to check: The behaviour that tells you the message worked: scroll depth past the hero, clicks on the button, completed signups. Pick one per row.

Practical rule: If a row has no words you could paste into the page, the row is not finished.

How to Design a Customer Journey Map in 7 Steps

Designing a customer journey map takes seven steps, from choosing one persona and goal to marking the riskiest assumptions for testing. The sequence is deliberate: the visitor side comes first, and the page side only after you understand where visitors come from.

  1. Pick one persona and one goal. Name the visitor and the signup. If you have several audiences, start with the one that sends the most traffic.
  2. Define the scope and the stages. Start at the entry point and end at confirmed signup, plus one "after signup" row. Use the five stages above, merged where they would share a message.
  3. Gather what you know about visitors and where they arrive from. Pull traffic sources from your analytics, search queries, ad groups, newsletter links and support questions. Write down the top entry points. Do not invent visitors from imagination.
  4. Fill in actions, thoughts, emotions and pain points. Complete Table A for each stage. Use real phrases from support emails, sales calls and search queries.
  5. Write what the visitor needs to hear at each stage. One sentence per row, answering the question in their head.
  6. Write the page message and CTA for each stage. Turn each "need to hear" sentence into a headline, a supporting line and a button label.
  7. Mark the riskiest assumptions as hypotheses. Highlight the rows where you are guessing, and write the signal you will check. The A/B testing hypothesis article shows how to phrase them.

The finished map should fit on one screen per entry point. If it takes a workshop to explain, cut rows.

What Do Filled-In User Journey Mapping Examples Look Like?

The three examples below are illustrative scenarios, not company case studies. They use the same imaginary product, a scheduling tool for small teams, and the same template rows, so you can see how one page needs different messages for different entry points. They contain no results, because none are claimed.

Example 1: a visitor arriving from search: Persona: A team lead who searched for a way to stop double-booked meetings. Entry point: An organic search result.

Question in their head: "Does this fix the problem I just described?"

StageNeeds to hearPage messageCTA
ConsiderationYes, this is about the exact problemHeadline names the problem in the searcher's words: "Stop double-booked meetings"Scroll prompt or "See how it works"
DecisionIt works for a team like mineShort line on how a small team sets it up, plus one proof element"Start free"
SignupSigning up is quick and low-riskForm with one field and a line about what happens next"Create my schedule"

This visitor is problem-aware. The page leads with the problem, not the product name.

Example 2: a visitor arriving from a paid ad: Persona: The same team lead, clicking an ad that promised "Set up shared calendars in minutes." Entry point: A paid ad with a specific promise.

Question in their head: "Is this the thing the ad promised?"

StageNeeds to hearPage messageCTA
ConsiderationThe promise is real and matches the adHeadline repeats the ad's promise: "Shared calendars, set up in minutes""Set up my calendar"
DecisionThe "minutes" claim is believableThree-step visual of the setup"Start free"
SignupThere is no catchForm that asks for as little as possibleButton repeating the ad's verb

The risk here is mismatch. If the headline drifts from the ad, the visitor leaves in seconds. The blog's campaign message match skill page is a quick check for this.

Example 3: a visitor arriving from a newsletter or referral: Persona: A visitor who trusts the sender and already knows roughly what the product does. Entry point: A newsletter link or a recommendation from a colleague.

Question in their head: "What do I do next?"

StageNeeds to hearPage messageCTA
ConsiderationI am in the right placeHeadline acknowledges the source: "Welcome from the newsletter" with the one idea they clicked forPrimary button visible without scrolling
DecisionLittle needs provingOne short line of reassurance, not a full pitch"Start free"
SignupLet me get on with itShort form, no extra steps"Create my account"

This visitor needs less persuasion and a shorter path. Showing them the full explainer slows them down.

How do you turn a journey stage into a page variation? Take one row and rewrite three things: the headline, the supporting copy and the CTA. Keep the offer the same and change the framing to match the entry point. Here is the Consideration row for a generic page versus a stage-matched page.

  • Generic page: Headline: "The smarter way to manage your team's time." Supporting line: "Powerful scheduling for modern teams." CTA: "Get started."
  • Search visitor with a double-booking problem: Headline: "Stop double-booked meetings." Supporting line: "See every teammate's availability in one shared calendar." CTA: "See how it works."
  • Paid-ad visitor promised a fast setup: Headline: "Shared calendars, set up in minutes." Supporting line: "Connect your team's calendars and share one view." CTA: "Set up my calendar."

The generic version is not wrong. It just answers no particular question. For headline wording ideas, see the landing page headline examples.

Writing and maintaining three or more variations by hand is the hard part. Polish is an AI agent that reads visit signals, such as where visitors come from, and rewrites headlines, copy and calls to action for each visitor. That makes the per-entry-point rewriting automatic, so the map's entry-point column becomes distinct page variations rather than a note.

What Are the Most Common Mistakes When Using a Journey Map Template?

The most common mistake is stopping at Table A. A team documents the visitor's feelings, agrees they are accurate, and never writes the words. Others are as follows:

  • Mapping everyone at once: An "average visitor" does not exist. A blended map produces a blended headline that answers no one's question.
  • Ignoring the entry point: A map that starts at "visitor lands on the page" hides the fact that a search visitor and a newsletter reader arrive with different expectations.
  • Too many stages: Each extra stage needs its own message. If you cannot write a distinct headline for it, merge it with a neighbour.
  • Inventing the visitor: Emotions written from imagination are guesses. Use support tickets, sales calls and search queries.
  • Writing pain points as solutions: "Add a testimonial" is an action, not a pain point. The pain point is "I do not know if this works for a company like mine."
  • Treating the map as finished: A map that is never revised is out of date as soon as traffic sources change.

Practical rule: Every cell in Table B should be something you could be wrong about, and every cell should name how you would find out.

When Does a Journey Map Stop Being Enough?

A journey map stops being enough when you need to know whether its page messages actually work. The map is built from judgment and incomplete data. Treat every row as a hypothesis, not a fact, and check it against live traffic.

That changes what "finished" means. A map is finished when it is testable, not when it is correct. The signal column tells you what to watch. If the search-visitor headline is supposed to keep people reading, check whether they scroll. If the paid-ad headline is supposed to match the promise, check whether they click the button.

Doing this by hand means writing variations, splitting traffic, waiting and keeping the winner, for each entry point. Polish does this continuously: it tests variations on live traffic and keeps the versions that generate conversions. The map supplies the starting hypotheses, and live traffic supplies the verdict. If you want to run your own tests first, the A/B testing article covers the basics.

What is the difference between a current-state and a future-state map? A current-state map records what happens today: the headline each visitor actually sees, the questions they actually bring and the points where they actually leave. A future-state map records what you want to be true after the changes: the new page messages and the behaviour you expect.

For a signup page, work in this order:

  1. Fill the template with today's page copy in the page message and CTA columns. This is the current state.
  2. Mark the rows where the copy does not answer the visitor's question.
  3. Rewrite those rows. This is the future state.
  4. After a test period, copy the winning wording into a new version of the map and note what the visitor actually did.

Keeping both versions shows you what you changed, and why. Then the next round of the map starts from evidence instead of memory.

Your Next Steps

You can go from a blank template to a testable page in one working session. Work through this sequence.

  1. Copy the header block and both tables into a tool your page editors use.
  2. Choose one persona and write the signup as the single goal.
  3. List your top three entry points from your analytics.
  4. Fill in Table A for each entry point, using real visitor language.
  5. In Table B, write the question, the "need to hear" sentence, the page message and the CTA for each stage.
  6. Mark the three riskiest rows as hypotheses and name the signal for each.
  7. Publish the rewritten copy for the entry points you can distinguish, and compare results.
  8. Update the map with what visitors did, and save it as the next version.

The template, the stages, the columns and the testing loop are one process. The stages give the map its shape, the entry point and visitor question tell you what to write, and the page message and CTA put it on the page. The signal column then tells you whether you were right, so the next version of the map is built on behaviour instead of opinion.

Polish is an AI agent for founders and website owners who want more signups: it reads visit signals and rewrites headlines, copy and calls to action for each visitor. It keeps testing variations on live traffic and keeps the ones that convert, so the hypotheses in your journey map get checked automatically at Polish.

  • user journey mapping template
  • user journey mapping

Share this post

Your website rewrites itself until it converts.

Polish writes new versions of your headlines and CTAs, tests them on your real visitors and keeps the ones that win.

Start free