The practical answer
- Short answer
- You hired 50% more people and revenue grew 20%. That gap is the Series B trap — and it quietly carves a 20% key-person discount off your next valuation.
- Best fit
- Industry: B2B Tech. Function: Operations
- Operating path
- Process Documentation → Operational Excellence → Transaction Execution Services
- Key metric
- 20% Valuation Discount applied to firms with high Key Person Risk
You added 30 people. Why did the machine slow down?
Here is the moment a lot of founders don't see coming. You closed the Series B at roughly $10M ARR. You did everything the deck promised: hired the VP of Sales, the Head of Product, and thirty individual contributors. Headcount jumped 50% in two quarters. And then, for the first time, you missed a number.
Not because the product broke. Because the machine building it broke. The new reps are ramping at half the speed your "founder-led" pipeline implied. Onboarding that used to take three weeks now takes three months, because the actual playbook — how you scope a custom integration, how you decide which deals get a discount, how a ticket goes from "in progress" to "shippable" — lives entirely in the heads of four early employees. Including yours.
This is the Series B trap, and it's a math problem before it's a leadership problem. Run the one ratio that exposes it: revenue per employee. You grew the team 50% and revenue 20%. That gap isn't a rounding error — it's the cost of every new hire spending their first quarter pulling answers out of three overloaded people instead of out of a system. The market is brutal about this stretch: roughly 35% of startups never make it from Series A to Series B, and the ones that stall on the way to C usually fail operationally, not commercially. The thing you built works. The thing you built to build it does not.
At $5M ARR you can willpower your way through any bottleneck at midnight. At $15M ARR, you ARE the bottleneck — and the next buyer prices that in.
The discount you can't see until the data room
Here is where the Tuesday-night Slack message you sent to unblock a deployment turns into a line item on your cap table. When a Series C lead or a PE sponsor diligences you, they are not buying your revenue. They are buying a system that produces revenue without you in the loop. The second they discover that critical decisions route through one or two people, they stop pricing a software company and start pricing a key-person risk.
This has a formal name and a formal range. Appraisers apply a key-person discount of 15–20%, occasionally up to 50%, when operational knowledge is concentrated in a handful of individuals. Do the arithmetic on your own deal: at a $100M target, founder dependency is quietly carving off $20M. That is not a soft "culture" cost. It's the most expensive consequence of never writing anything down.
Find your number: $200K per head
The diagnostic is one figure. For a healthy SaaS company in the $10M–$50M ARR band, revenue per employee should sit around $200,000–$250,000. Pull yours this week. If you've slipped under $150K while scaling, you are no longer running a software business — you're running a high-touch services bureau with a SaaS logo on it, and that's a different multiple entirely.
The gap between $200K and $150K is almost never a talent problem. It's the tax you pay for undocumented process. Without a written definition of how work gets done, every hire subtracts value before they add it, because the only way they learn is by renting time from your most expensive people. The counter-evidence is just as concrete: organizations with clearly defined standard operating procedures outperform their peers by around 31%. The documentation that felt like bureaucracy at Series A is the asset that defends your multiple at Series C.
The Monday move: stop being the integration
Escaping this stretch doesn't mean a 300-page handbook nobody opens. It means turning the four people who carry the company in their heads into a system of record for how value actually gets created. Three concrete steps, in order.
1. Audit where you're still the API
For one week, track every decision that bounces back to you. Be specific to a Series B org: pricing exceptions, custom-scope approvals, final-round hiring calls, "is this deal worth the discount" judgments. The 20% of decisions that eat 80% of your week are your true bottlenecks. Extract the logic — a one-page decision matrix or a five-minute Loom beats a meeting. If you can't articulate the rule you're applying, you're not operating, you're improvising, and improvisation doesn't scale to thirty new people.
2. Write a "definition of done" for every function
Ambiguity is what's actually slowing the machine. Sales needs a non-negotiable definition of a qualified lead. Engineering needs a precise bar for "ready for QA." When those operational readiness metrics are explicit, the cross-functional finger-pointing that paralyzes scaling companies simply stops — because everyone is arguing against a written standard instead of against each other's memory.
3. Make the playbook the promotion criteria
Reframe documentation from "extra work" to the work itself. At this size, if a process isn't written down, it doesn't exist — it's a liability waiting for someone to quit. So tie advancement to it: a director doesn't just hit the number, a director builds the system that lets other people hit the number without calling you at 11 PM. That's the whole transition from Series B to C — founder-led to process-led, exciting-but-fragile to predictable-and-investable. You've already proven you can be the hero. The next round pays for the architect.
