Signup Flow

Signing up was treated as a single screen for a long time. A designer drew the signup page, an engineer built it, and the job was done. Look at it as one screen and everything worth fixing is inside that screen: the button color, the spacing around the fields, the wording of the helper text.

Teams kept making those fixes and watching the number stay put, because the place people were dropping out wasn't inside a screen. It was between screens — while waiting for a verification email after hitting submit, while leaving the product to find the message, while coming back to a form that had forgotten everything already typed. None of those are design problems on the signup page.

Pagedeck lived through this. Noa redrew the signup screen, tidied the fields, and rewrote the copy, and three weeks later the conversion rate was unchanged. When Theo opened the logs, more people were reaching submit than before — and the verification email was being classified as spam by corporate mail servers, so a third of them never made it back. Naming the whole sequence as one object, rather than the screen, is what this term is for.

The flow breaks into five positions.

1. Entry. Where someone arrived from changes what the first screen should be. A visitor from the pricing page has already picked a plan; a visitor from a colleague's invite link already has a team to join.
2. Identification. The fields that distinguish an account — email and password entered directly, or a social login button that lets someone in with an account they already have.
3. Verification. Checking that the email address or phone number really belongs to the person. This is the only position where the user leaves the product to go somewhere else, and the losses here are the largest.
4. Initial setup. Naming a team, inviting colleagues.
5. Arrival. The product's first screen.

What you manage is the pass-through rate between positions. Pagedeck's last quarter: 10,000 visits, 2,400 reaching the signup screen, 1,800 submitting, 1,200 verifying, 1,150 landing on the first screen. As rates between steps that reads 24 percent, 75 percent, 67 percent, 96 percent.

What you're hunting for is not the lowest number but the number that sits well below its neighbors. The 24 percent in the first gap is naturally low — plenty of those visits were people looking around. The 67 percent in the third gap needs explaining, because it means one in three people who already typed out an email and a password disappears. A position that loses unusually many people like this is called a funnel leak.

The flow rarely runs as a single path. Someone arriving through an invite skips position 4, and a product offering a free trial — full access for a fixed period — splits again after position 3 over whether to ask for payment details. Once paths multiply, each one needs its own pass-through rates. Averaged together, a month heavy in invite traffic lifts the combined rate on its own and looks like a product improvement. The fix is boring and necessary: tag the entry point on every session and keep the rates split by that tag from the beginning, because the split cannot be reconstructed from logs that never recorded it.

The term comes up most often in the meeting that picks what to improve next. Every user has to cross this neck, so a single percentage point of pass-through lifts the headcount in every box behind it. When it's blocked, no amount of quality deeper in the product matters, because nobody gets there to see it.

It also serves as the unit of an experiment. Rather than making two versions of one screen, teams build two versions of the whole flow — five fields on one page against two fields across three pages — show each to half the traffic, and count arrivals. Measured screen by screen, losses that happen on the next screen never reach the scorecard, so the variant that merely looks good early wins.

Design keeps the flow drawn as a user flow document, which maps screens and the branches between them. You need the picture to see where invited users and search visitors diverge and where they rejoin, and to notice a path nobody built.

This is also where legal and security requirements land. Terms acceptance, age verification, business verification all live inside the flow. Where a requirement sits changes the pass-through rate, so even an item that can't be removed can have its position negotiated. An age check in front of the signup form is a wall; the same check at the moment someone first publishes something is part of the work they came to do.

"Let's build two versions of the whole signup flow. Changing one screen won't settle it."

The losses are between screens, so the comparison has to be at flow level.

"People who came through invites go through a different signup flow, so count them separately."

An averaged rate can't tell an improvement from a shift in traffic mix.

"Can age verification move to the end of the signup flow? We're losing 30 percent where it sits now."

A required item can still have its order changed.

Pagedeck attacked that 67 percent verification gap two ways at once. The verification mail moved to a sending address on the company's own domain to cut spam classification, and the order changed so people could look around the product while waiting, with verification deferred to the moment they tried to save a document.

Two weeks later the third gap read 84 percent. Deferring verification did let more accounts get created from fake addresses, so Theo had to build a separate cleanup job for them.

The most common belief is that fewer screens is always better. It's a reasonable inference, since everyone knows more fields means lower conversion. But advancing a screen carries a cost too, and a single page crowded with fields makes people quit on sight. Five fields on one page beating two fields across three pages happens, and so does the reverse. Left uncorrected, a team spends its effort collapsing screen counts and never touches the verification gap where the real loss is.

Treating this as a design problem is the second misreading. Screens are the visible part, so that's where attention goes. The largest losses are decided outside the screen: whether the mail arrives, whether the form still holds what was typed when someone returns, whether an error message says what was actually wrong. That is more than a designer can fix alone, which is why engineering belongs on this work from the start.