Mock data usually looks real, then falls apart under analysis.
This system generates relational CX data that behaves correctly in dashboards and reporting, using deterministic structure with a narrow, controlled role for AI.
When the Data Looked Real and Failed
When I joined a CX platform, the advice was simple: use a mock-data tool like Mockaroo.
I opened the CSV, and it looked like exactly what I needed. A few clicks produced thousands of rows, names, emails, and locations, all of it convincingly realistic.
Then I imported it into the system as historical response data.
Leaderboards showed one response per person. Locations didn't group into anything meaningful.
The reporting was technically correct and completely useless.
The biggest gap was the lack of a real concept of feedback: no topics, no patterns, nothing to actually learn from.
As a customer experience and feedback company, this defeated the entire purpose of the exercise.
So I tried to fix it by hand. I built comment sets, used INDEX(RANDBETWEEN()) to distribute them, and copied rows to simulate density.
I could make the data look real in the spreadsheet. I could not make it behave real once the system tried to use it and realized it was a really hard problem to solve without real customer data.
The Real Problem
The problem was never generating data. It was generating data the system could operate on, and that took a real understanding of how the system behaves.
Doing it well needed three things at once:
- advanced spreadsheet skill
- a deep grasp of how the product works
- a mental model of how customer environments are actually structured
Those are exactly the things a new user doesn't have yet.
To learn the system, you needed good data.
To make good data, you already had to understand the system.
I first encountered this when I joined the company in 2020 and didn't have the time or depth to solve it then, but it kept resurfacing throughout my 5-year tenure, especially when I was trying to teach new hires.
Over the next few years, as I learned how data flowed through the product and how reporting actually behaved, the shape of the fix came into focus.
Eventually I built the version I wish I'd had on day one.
What I Built
Eventually, after a ton of real customer implementations, developing my advanced spreadsheet skills, and, honestly, some good old-fashioned experimentation, I cracked it.
What resulted was a configurable simulation engine that models a full customer-experience environment as structured, relational data with controlled variation, or the Storyteller Engine 📣
It models the real pieces and the relationships between them:
- Businesses built around frontline, people-powered service.
- Locations, each carrying its own regional brand.
- Frontline staff, each assigned to a specific location.
- Response behavior, with realistic response rates and a meaningful spread of scores.
- Qualitative feedback, with topics and contextual comments.
Everything is generated so that relationships hold, distributions stay realistic, and the data tells a story once it is inside the system.
The goal was data that behaves correctly under analysis within a user’s dashboard, not data that only looks right row by row in a spreadsheet.
How It's Built
The whole thing runs on relational integrity: nothing is generated in isolation, and every record inherits from the layer above it, so the result is always valid combinations at scale.
- 01
Configuration Layer
The run starts here: business type, region, sentiment bias, and response rate, with defaults that produce realistic data out of the box and room to customize without breaking the set.
- 02
Reference Layer
A mapping layer defines how everything connects, tying business types to service standards, regions to brands, and locations to staff, so groupings hold up in reporting.
- 03
Data Generation Layer
Contacts, staff, and locations are created through filtered logic (
INDEXandFILTERover valid pools), so every combination is a real one rather than a random pairing. - 04
Response Simulation Layer
Responses spread across a rolling window with
RANDBETWEENinside set bounds, scores follow defined distributions, and some contacts deliberately don't respond, so trend lines and NPS behave over time. - 05
Comments
Templates are filled by industry × topic × sentiment and injected with staff, business, and location context, so the qualitative feedback matches the experience being simulated.
- 06
Validation Layer
A checking layer verifies response rate, score distribution, and per-agent volume, so the data is statistically meaningful rather than only plausible-looking.
- 07
Structured Output
The result is import-ready datasets in the correct load order, so the environment deploys without breaking on dependencies.
Survey Experience Flow
This demonstrates the journey customer data takes through the platform, from contact creation to response submission, so the simulated data reflects a real customer journey and aligns with the standard NPS survey design.
The AI Piece: Constrained, Not Freeform
The comment templates are the one place AI does real work, and it is deliberately boxed in.
Instead of freeform generation, a constrained prompt enforces:
- industry-specific language
- strict sentiment alignment (promoter, passive, detractor)
- conversational length of one to three sentences
- structured placeholders for reuse.
That keeps coverage complete, tone consistent, and the building blocks reusable across large datasets.
Example Prompt Template
Generate a realistic, industry-specific NPS comment template for a {{business_type}} based on {{topic}}. Sentiment: {{sentiment}} (Promoter=9-10 enthusiastic, Passive=7-8 lukewarm/mixed, Detractor=0-6 critical/frustrated).
Requirements:
- Make it HIGHLY SPECIFIC to the {{business_type}} industry - use industry terminology and concerns natural to that business
- Reference {{topic}} naturally and authentically
- Match the sentiment tone perfectly:
- Promoter: Enthusiastic praise, specific strengths, would recommend
- Passive: Some positives but also weaknesses, neutral/hesitant tone, "could have been better"
- Detractor: Frustrated/disappointed, specific complaints, wouldn't recommend
- Keep it 1-3 sentences, conversational, like a real customer review
- Include placeholders [name], [business_name], [specific_example], [timeframe] where they fit naturally
- Avoid generic language - be specific to the industry and topic
Examples for reference:
- Pediatric Dentist + Calming Presence + Promoter: "[name] was so gentle and reassuring with my child. [business_name] really took time to explain each step, which made [specific_example] so much less scary."
- Auto Service Center + Transparency + Detractor: "I was confused about the repairs needed and [name] didn't explain it clearly. When I got the bill from [business_name], the charges seemed inflated compared to what [specific_example] should cost."
- Fine Dining + Pacing + Passive: "The courses at [business_name] came out at a reasonable pace, though I felt like [name] could have been more attentive during [specific_example]. Service was adequate but not memorable."
Generate an authentic template now:
Impact
Faster onboarding
New team members could explore realistic environments without having to build datasets from scratch.
Demos that hold up
Leaderboards, trends, and reports all reflected meaningful patterns, so the insights lift right out of the dashboard.
Repeatable testing
Features and edge cases could be validated in a controlled, repeatable environment.
Qualitative insight that fits
Comments aligned with sentiment and context, so coaching and reporting felt real.
What I'd Improve
Expand the comment library to cut repetition and improve realism.
Add scenario presets, such as enterprise versus SMB or multi-brand complexity.
Support location scaling beyond fixed sets.
Add an error-handling and diagnostics layer for debugging configurations.
Build a lightweight interface for people who don't want to work in the spreadsheet.
On the AI
AI has one bounded job here: filling constrained comment templates within a fixed structure of industry, topic, and sentiment.
Everything that carries the system: the relational model, the generation logic, and the validation is deterministic and built by hand.
The AI works inside the structure; it doesn't define it.