
Everybody Knows Alice
Phillip Harrington Nov 2026
TL;DR: Write your seed data as numbered scenarios with named, fake people. Then the same scenarios become your dev data, your mockups, your acceptance criteria, your QA scripts, your bug reports, your test fixtures, and your sales demo. One story, told everywhere.
I didn’t invent this
I’ve pitched this at every company I’ve worked at since. So far, zero of them have done it. I keep bringing it up, so I’m writing it down. You know, say it once.
“Since,” because it isn’t my idea. I saw it done once, on the web app for the Next Generation Experience project at a little-known company you’ve probably never heard of: The Walt Disney Company. They had the scenarios, the named people, all of it. I’ve been trying to steal it ever since. There’s nothing new under the sun. The least I can do is say where I got it.
And the best part: the known users were the cast of Modern Family. An ABC show, so, a Disney show. Which was perfect, because the whole point of the app was planning your friggin’ day at the parks: bookings, FastPasses, and every permutation of who’s doing what, with whom, and when. A big, sprawling, complicated family gives you all of those permutations for free. And everybody already knew who those people were. Well, everybody except me. I’d never seen it, so I started watching, just to keep up at work. Fantastic show, by the way. And after that, I never had to ask what kind of user Phil was, either.
Day one, the data is a mess
Here’s what local data usually looks like on day one at a new job:
- An empty database, and good luck.
- A dump of production, which is a privacy incident waiting for a laptop to get left in a cab.
- A pile of users named test1, asdf and foo, with passwords nobody remembers, in states nobody can explain.
- Or a thousand generated fake users, which is great until you realize your thousand and my thousand aren’t the same thousand. Your “user 42” isn’t mine.
And please, not production. Not a copy of it, and not a copy where “we replaced all the names,” either. Yes, it’s a security incident waiting to happen. Scrubbed data has a way of not being scrubbed: an address in a notes field, a phone number in a comment. But that’s not even my real objection. It’s lazy. Production data is a pile of whatever happened to happen. Nobody knows what’s in it, it’s different every time somebody refreshes it, and you can’t point at any of it and say “that’s scenario 12.” I’ve heard it pitched at a few companies, and nobody has ever made it make sense. It skips the one part that matters: deciding what the stories are.
And then the conversations go like this:
“Can you reproduce it?”
“Which user?”
“The one with the expired trial. Who has an invitation. I think.”
“Is that test4?”
“...What’s test4’s password?”
Half an hour gone, and nobody’s looked at the bug yet.
Give every scenario a number and a name
Instead, seed your database with scenarios. Each one is a small, numbered story with named people in it:
- Scenario 7: Alice is on the free plan, at her limit. She tries to make one more.
- Scenario 12: Alice invites Bob to her checklist. Bob hasn’t accepted yet.
- Scenario 13: Bob accepted. Alice removes him. Bob clicks the old link anyway.
- Scenario 21: Carol’s Pro trial ended yesterday.
Everybody logs in as alice@example.com, and the password is always password. Always. Nobody has to ask.
Now the conversation goes like this:
“It breaks in 12, when Bob opens the link.”
That’s it. Everyone on the team knows exactly who Bob is, what he has, and what he’s about to click. Everybody knows Alice.
Pick a cast everyone can picture
Alice and Bob are fine. A TV show is better. Disney had the Modern Family crew. When I lobbied for this at a K-12 software company, everybody loved the idea and immediately voted for the cast of Abbott Elementary. Pick your favorite show. Or make people up. Doesn’t matter, as long as everybody can picture them.
Give them personalities while you’re at it. One knows exactly what she’s doing. One is always a little confused. One is trying to break it, on purpose. Carly is a photographer and James is her assistant, so “Carly invites James as a collaborator” tells you who, why, and what James is going to do next. Do it right and the company falls in love with them. Good old Alice. Oh, Bob again.
If this sounds familiar, it should. Product and UX folks have had personas for decades: made-up people with names, goals and habits, so the team designs for somebody instead of everybody. This is the same idea, carried all the way into the database. A persona you can log in as.
Then it pays off everywhere
The same scenarios, reused all the way down the line:
- Dev work. New developers start on day one with a database that makes sense, and it’s the same database on every laptop. Not a week of asking which account is safe to break. Need a thousand random users for load testing? Generate them on top. The scenarios stay put underneath.
- Acceptance criteria. “Given scenario 12, when Bob opens the invitation, he sees Alice’s checklist.” Product writes against people everyone already knows, instead of describing the setup from scratch every single ticket.
- Mockups. “Alice’s invitations screen.” “Phil clicks Cancel.” The mockups are made from the seed data, so the names and the stuff on screen match what devs see when they log in. One mockup labeled “scenario 25, step 3” replaces the six screens that used to lead up to it. A dev logs in as the right person, walks 25 to step 3, and goes “ohhh, that’s where they want the icon.”
- QA. The acceptance criteria are the test script. Load the seeds, be Bob, click the thing.
- Bug reports. A ticket comes in: somebody did X, then Y, then Z, and it broke. Find the closest scenario. If it’s exactly 12, you’re reproducing it in thirty seconds. If it’s 12, but Bob already had an account with a different email? That’s 12b, a new scenario seeded right next to 12, with a test to go with it. The next time it happens, it’s a number.
- Automated tests. The unit and feature tests build the same people with the same helpers. Fix a bug, add a test, and if the bug needed a situation nobody had seeded yet, add a scenario. The story grows with the code.
- Sales demos. Same seeds, or a polished set of their own. Picture sales-demo-3.yourapp.com with a button that says Reset. Sales can break things, delete things, and pile in the prospect’s favorite stuff, right there in the room. Then click Reset, and Alice is back at her limit and Bob is waiting on his invitation.
More what you’d call guidelines
“The code is more what you’d call ‘guidelines’ than actual rules.”
Like Barbossa said about the pirate code, these aren’t really rules. But it works best if you’re a little strict about them.
- Fake people only. @example.com addresses, made-up names, the password is password. No real person, ever. I say this because I found my own real email and a real password hash sitting in a seed file this week. In my own repo. Rotated, fixed, humbled.
- Number them, and name the people. Numbers for the ticket, names for the conversation. “Scenario 12” and “when Bob opens the link” should both mean exactly one thing.
- Don’t change what a scenario means. Scenario 12 is Alice-invites-Bob forever. Need something different? That’s 12b, or scenario 31. Never “well, for this ticket, 12 means...” and it changes three times. Old tickets, old test names and old bug reports still mean what they said.
- Every scenario stands alone. The cast is shared: Alice shows up in a dozen scenarios. But each scenario owns its own stuff, the specific thing it’s about, sitting there in exactly the state it needs. Scenario 145 has its own checklist for Alice to wreck. No running them in order. No building up the data by clicking through the app first. Go straight to 142. Break 12 all you want; 142 doesn’t care.
- One way to build a person. The seeds and the tests use the same helpers to make Alice. Not two copies that quietly drift apart.
- One command to reload.
make seed, or a button. Better yet, reset just the ones you’re working on:seed:reset 12a 142, sitting in your shell history, one up-arrow away. Break it, hit up and enter, and break it again. Go further and wire it into your browser tools, so the reset fires from the page you’re testing. However you do it, if resetting is a chore, nobody does it, and you’re back to test4.
Start with five
Fair warning: make(1000) is faster. Scenarios take thought, and they take the business, because the business is who knows the stories. That’s the point, not the cost. The scenario names become part of how everyone talks, product, support and devs alike. If you’re into Domain-Driven Design, it’s right next door to ubiquitous language. Call it a ubiquitous cast.
You don’t need all of it on day one. Pick the five situations your team argues about most. Write them down as scenarios, with names. Seed them. Use the names out loud in the next daily sync-up.
That’s the whole trick. It turns “can you set up a user who...” into a number. And numbers are fast.
Final thought
Every team already has these stories. They’re just stuck in people’s heads, retold slightly differently every time someone files a bug.
Write them down once. Give them names. Seed them.
Then let everybody know Alice.
$2 tip: If your team has to ask who test4 is, nobody wrote your test data. It just happened.