Skip to content
Faisal Mahmud TusherDigital marketing, SEO & analytics
with Faisal Tusher

Product Marketing › Sales Enablement

Writing a Product Demo Script

How to write a product demo script that tells the buyer's story: discovery first, one situation per use case, the moments that prove it, and a talk track.
Tutorialintermediate10 min readUpdated

Why a feature tour loses the room

The default demo is a tour. The presenter opens the product, starts at the first menu and shows what each screen does, because that is the order in which the product was built and the order in which the presenter learned it. For the buyer it is the wrong order. They arrived with a problem, and the tour makes them hold that problem in their head while they translate each feature into whether it helps. Many stop translating after the first few screens, and the questions at the end are about price rather than value.

The sales content and training guide describes the alternative in outline: a narrative demo starts with a situation the buyer recognises, shows the product resolving it and ends with the outcome, is written for each main use case and persona, has a short version for early calls and a deeper one for evaluation, and needs realistic data. This tutorial turns that outline into a script someone can run.

A demo is also a claim. Whatever the product is shown doing, the buyer will take as something it does, today, for them. The messaging hierarchy and proof points guide treats a capability the buyer can see in a demo as one of the strongest forms of proof, which is exactly why the script must only show what the product really does. A mock-up of planned capability, presented as if it were live, turns the strongest proof into a misleading one.

Before you start

Collect the inputs. You need the current messaging hierarchy, with its pillars and the proof under each; the messaging house template, if the company uses one, with the sales cut of each pillar; the main use cases and the buyer personas sales meets; and a handful of recorded or written-up discovery calls from recent deals, won and lost. Win-loss notes help most, because they say which moments in a demo buyers remembered.

Agree who owns what. Product marketing owns the narrative and the claims; a solution engineer or senior representative owns whether it runs; product management confirms what is live, for whom and on which plans. Agree, too, where the script will live, because a script in a personal folder is a script nobody updates.

Decide which motion the demo serves. In a sales-led sale the demo is a meeting a representative runs; in a product-led one the buyer often explores alone and a recorded or guided demo plays the same part. The comparison of product-led and sales-led growth sets out how the two motions differ. This tutorial assumes a live demo; the same narrative serves a recording with the questions written as captions.

The steps

  1. Collect what discovery says about the buyer

    A demo comes after discovery, and the script needs to say what the presenter should know before starting: the situation that started the search, what the buyer uses today, who else is involved and what would count as success. List those as the script's opening checklist. If discovery has not answered them, the first minutes of the demo ask the questions instead of showing screens. A presenter who demos without knowing the situation has no choice but to tour the product.

  2. Choose one situation per use case

    For each main use case, write the situation the demo opens on as the job the buyer hires the product to do. The jobs-to-be-done framework, as set out from Harvard Business Review's article on knowing customers' jobs, describes customers as hiring products to make progress in a particular circumstance, with functional, emotional and social layers. Write the situation in the job-story form the framework page gives, with no product in it, and check that a buyer in that use case would recognise it as their own week. One situation per use case keeps the demo a story; several situations in one demo turn it back into a tour.

  3. Pick the few moments that prove the pillars

    A moment is a point in the demo where the buyer sees the situation resolved. Choose a few, each tied to one messaging pillar and to the proof the hierarchy lists under it, and cut everything else. Order them as the situation unfolds, not as the menu runs. For each moment write down the pillar it proves, what the buyer sees and the claim the presenter makes. Anything the product does that proves no pillar stays out of the main narrative and goes into the deep cut or the answers to questions.

  4. Write the talk track: tell, show, tell

    For each moment, write three short parts. Tell: what the buyer is about to see and why it matters to the situation. Show: the clicks, in order, with what to point at. Tell again: what just happened, as a benefit in the buyer's words. The features, advantages and benefits chain is the discipline for the second tell, and its page notes that demo scripts often use it and that it works best after the buyer has described their situation. Keep the talk track to sentences a presenter could say naturally; it is a model to adapt, not a text to recite.

  5. Build demo data that looks like the buyer's world

    Empty screens and test records called "Test 1" undo a good narrative. Build a demo account with names, numbers and records that look like the buyer's industry and size, with the situation the demo opens on already present in the data. Keep one account per main use case, document how to reset it, and check it does not contain real customer data. If the data has to be adapted for an account, the script says which fields to change and which to leave alone.

  6. Add branches for each role in the committee

    Business purchases are rarely decided by one person; the buying committee definition describes the group of roles involved. Write a short branch for each role likely to attend: a moment or a different emphasis for the person who will use the product daily, the person who pays, and the people who check risk. The guide to marketing when the buyer is not the user explains why each role has its own job and its own worries. A branch for a finance buyer, for example, shows the same situation through what it costs today and what changes after, rather than through the screens a user would care about.

  7. Plan the short and the deep cut

    Write two versions from the same narrative. The short cut, for early calls, keeps the situation, the most important moments and the outcome. The deep cut, for evaluation, adds the remaining moments, the role branches and the detail evaluators ask about: set-up, administration, integrations and limits. Mark in the script which moments belong to which cut so that a presenter can move between them when the meeting changes shape.

  8. Script the questions and the hand-back

    Write the questions the presenter asks at each moment, such as whether this is how the buyer handles it today or who else would need to see it, because a demo that never pauses becomes a presentation. Then script the end: a summary of the situation and the outcome in the buyer's words, an invitation to raise anything not shown, and the next step agreed in the room. Questions about competitors are answered from the competitive battlecards, not from the script. When the deal moves on to the business case and security review, the late-stage deal content guide covers what the champion needs next.

  9. Rehearse and certify

    Run the script with the people who will deliver it, with someone playing each role in the committee, and fix whatever breaks: a moment that takes too long to reach, a branch nobody can remember, a screen that loads slowly. Certification and role-play belong to the training programme, and the sales content and training guide sets out how representatives are certified by delivering a demo narrative to someone playing the buyer.

  10. Keep the script current with each release

    Every release can change a screen, a claim or a limit. Make checking the demo scripts part of the launch process, with an owner and a review date on each script, and remove any moment the product no longer supports before a buyer sees it. When a release adds a capability that proves a pillar better than the current moment, swap it in. Review the script whenever the messaging changes, and when win-loss interviews show buyers remembering something other than the moments the script intended.

The anatomy of a demo script

A finished script is a short document with the same parts in the same order, so that anyone running it knows where to look.

PartWhat it holdsWhy it matters
Discovery checklistWhat the presenter must know before starting, and the questions to ask if notStops the demo turning into a tour
SituationThe buyer's job in job-story form, with no product in itGives the demo a story the buyer recognises
MomentsEach moment with its pillar, what the buyer sees and the claim madeTies every screen to the messaging and its proof
Talk trackTell, show, tell for each momentGives presenters a model to adapt
Demo dataThe account to use, how to reset it and which fields to adaptMakes the situation look real
Role branchesA moment or emphasis for each committee roleLets one demo serve several people in the room
Short and deep cutWhich moments belong to each versionLets the presenter fit the meeting
Questions and hand-backQuestions at each moment, the summary and the next stepTurns a presentation into a conversation
Owner and review dateWho keeps the script true and when it is next checkedKeeps the script in step with the product

Judging whether a script works is harder than it looks. Deal outcomes, including the win rate, depend on far more than the demo, so read them alongside what representatives and buyers say about the demo rather than crediting or blaming the script for them. Whether buyers get to a demo at all is a different question, about booking rather than content, which the demo scheduling experiment tests.

A site safety software rewrites its demo (illustrative)

Illustrative example — not a real result

Nuvelpra Site Safety replaces its feature tour

Nuvelpra Site Safety, an invented site-safety software for building contractors, ran a demo that started on the dashboard and visited 11 menus in order. Representatives reported that buyers asked about price after about 20 minutes and rarely about anything they had seen. Product marketing rewrote it as a script that opens on a site manager's morning inspection across 3 live sites, with the situation written as a job story: when I walk a site before the trades arrive, I want to log hazards and assign fixes from my phone, so the site is safe and I can show it. The script kept 3 moments, one per pillar: logging a hazard with a photo in the inspection, the fix assigned and closed by the subcontractor, and the record a client's auditor can open. A branch for the finance director showed the same inspection through the time spent on paper reports and rework. The demo account was rebuilt with 3 realistic sites, 40 open and closed hazards and named subcontractors, none of them real customers. One moment, a planned weather alert, was cut because it was not yet live. Over the next quarter, representatives logged that 18 of 26 evaluations asked a follow-up question about one of the 3 moments.

The same narrative carries into the other sales assets: the core sales deck tells the story the demo then shows, and the sales enablement hub sets out how demos, battlecards, training and feedback fit together.

Common mistakes

  • Starting on the dashboard. The first screen should be the buyer's situation, not the product's home page.
  • Showing everything. Moments that prove no pillar dilute the ones that do; they belong in the deep cut or the answers.
  • Showing planned capability as current. A demo is a claim; anything not live for the buyer is labelled as planned or left out.
  • Empty or fake-looking data. Records called "Test 1" make the situation hard to believe.
  • One demo for every role. The finance buyer and the daily user need different emphasis from the same story.
  • Reciting the talk track. The words are a model; the claims and the order are what stay fixed.
  • No pauses. A demo without questions is a presentation, and the presenter learns nothing.
  • Scripts nobody owns. Without an owner and a review date, the script drifts from the product within a few releases.

Frequently asked questions

Who should write the demo script: product marketing or the sales engineers?

Product marketing usually writes the narrative, because it owns the messaging pillars and the proof behind them, and the script has to say the same thing as the website and the deck. Solution engineers or the representatives who run demos shape it, test it and adapt it to each account, because they know where buyers lose interest and which screens break. A script written by one group without the other tends to be either accurate and dull or persuasive and unrunnable.

Should a demo script be followed word for word?

No. The script fixes the situation, the order of the moments, the claims made at each one and the questions asked; the words are a model, not a recital. A representative who reads the talk track aloud sounds rehearsed and stops listening. What should not change from one demo to the next is what the product is claimed to do, because that is a claim the company makes and it has to be one the product can back up today.

How is a demo script different from a battlecard?

A battlecard is an internal reference about one competitor: how the company wins and loses against it, the objection responses and the landmine questions. A demo script is the story of the buyer's situation told through the product. The two meet when a buyer is comparing alternatives, and the script can include a moment that shows a strength the battlecard names, but the competitive detail stays on the card.

Terms used on this page

Frameworks

Where this page is used

Also related

Sources

  1. Know Your Customers' Jobs to Be Done — Harvard Business Review

Related