Imagine you've invited six people to a dinner party. The invitations are written, addressed, beautiful. Each one says: come in, your seat is set, your meal is waiting.
Now imagine you post all six the moment they're done — before you've cooked anything, before the table is laid. Some guests turn up early. They walk into a cold kitchen and an empty table, holding a card that promised them dinner.
That was the trap we nearly walked into.
The invitation has to be true the second they open it
We were welcoming a group of people into a new shared workspace. The promise in each welcome email was the same: here is your space, and your own assistant is already in it, set up and ready to work alongside you.
That sentence is either true or false at the exact moment the person clicks the link. If they sign in and the assistant is there, the first thirty seconds confirm everything the email said. If they sign in and it's an empty room, the same email becomes a promise the product just broke — in the worst possible place, the very first impression.
The six emails were done. Drafted, personalised, sitting in a folder, ready to go. The instinct almost everyone has at that point is to send.
We held them. On purpose. Not for a set number of days — until one specific thing was true for each person: their assistant was built and actually placed in their room. Not before. Each person signs in to something that already has them in it.
An empty room with a card that promised a full one is worse than a slightly longer wait. The empty room does the damage. The wait doesn't.
A real sequence is a chain, not a checklist
Here's the part that travels well beyond welcome emails.
Lay the dinner out as steps: cook the meal, lay the table, post the invitation, the guest arrives and sits down. Every one of those has to finish before the next one makes sense. You don't post the invitation before there's food.
The tempting shortcut is to do it all at once. Send the invitations now, the thinking goes, and the cooking will be done by the time anyone actually arrives. It feels faster, and it quietly breaks the one thing holding the whole evening together — because nothing guarantees a guest arrives after the food is ready rather than before. Some people come the moment the invitation lands. That person gets the cold kitchen.
So here's the test I'd offer anyone who thinks they've built a proper sequence. Take any two steps that sit next to each other and swap them. If nothing breaks, they were never really a sequence — you had a checklist, and you were calling it a process. A real chain is one where each link genuinely needs the one before it closed first.
The bill for getting this wrong is paid once, by the guest
First impressions don't average out. Someone who walks into a warm, ready room and someone who walks into an empty one aren't two numbers you can take the middle of. The second person quietly decides whether this whole thing is real — and that decision is expensive to undo. You spend the next month earning back trust you could have kept for free by simply waiting.
So we waited. The emails went out one at a time, each one only after the room behind it was genuinely ready for the person it was addressed to. Slower on paper. Better in the only place it actually gets measured — the first time someone who isn't you walks into the thing you built.
Send the invitation when the room is ready. Not when the invitation is ready.
For the technical reader
The concrete setup: we were onboarding a small group onto a shared workspace where each person also gets their own AI agent — a working assistant provisioned into the same environment they'd be collaborating in. Six personalised invitation emails were drafted and ready.
The gate we enforced was conditional, not time-based. There was no week-long hold or fixed timer. An email was only sent once two things were true for that specific person: their agent had been built, and that agent had been loaded into their workspace. The trainee always signs in to a populated environment, never a blank one.
The pipeline had four stages, each separated by a human checkpoint that has to clear before the next begins:
- The person builds their agent.
- We load that agent into their workspace.
- We send the invitation email.
- They sign in and confirm the agent is live and responding.
The anti-pattern is parallelising stages 1–3 to "compress the calendar" — firing the emails on the assumption agents will be ready by login time. That removes the only real dependency in the chain, because login time is controlled by the recipient, not by you; an eager click beats the provisioning and lands the user in stage 4 against an empty workspace.
The swap-two-adjacent-steps test is the practical heuristic: if you can reorder any two neighbouring steps without breaking anything, the ordering was decorative and you have a list, not a sequence. A genuine sequence is one where each step's precondition is the previous step's completed output.