Your board just approved the next 18 months of runway. The money hits the account on a Tuesday. By Friday, three people have asked you the same question: "So, who are we hiring first?" And you realize, sitting in that chair, that your "hiring plan" is a spreadsheet with nine vague role names and a nagging feeling that you're about to spend a million dollars on the wrong people.

I've watched founders build headcount plans that looked beautiful in the deck and fell apart by month four. I've also seen scrappy two-person teams hire in a sequence that compounded their output every quarter. The difference almost never comes down to talent or luck. It comes down to whether the hiring plan is tied to a business milestone or just to a feeling of urgency. Here's how to build one that survives contact with reality.

Key takeaways

  • A hiring plan is a sequencing document, not a wishlist. Every role should map to a revenue, product, or operational milestone that justifies its cost.
  • The 70/30 rule in hiring means 70% of your hires should be proven operators and 30% should be stretch bets. Invert that ratio and you'll burn runway on learning curves.
  • Sequence hiring by stage: pre-seed hires generalists, Series A hires specialists, and the transition between the two is where most plans break.
  • Model the fully loaded cost of a role (salary, tools, onboarding time, and the cost of a bad outcome) before you sign anything.
  • Review the plan quarterly. A hiring plan that doesn't change when your revenue does is a plan that's already wrong.

How to create a hiring plan that's tied to business milestones

The most common mistake I see is building the hiring plan backwards. Founders start with the roles they think they need, then try to justify the budget. Do it the other way around: start with the milestone, then work out who has to be in the chair to hit it.

Concretely, that means writing down three things before you open a job description. The first is your next growth milestone. Something like "reach 500 paying customers" or "hit $1.2M ARR" or "launch the mobile app to beta." The second is the bottleneck that's currently preventing you from getting there. And the third is the specific output a new hire would produce that removes that bottleneck.

If you can't name the output in a sentence, you don't have a hire yet. You have a hope.

The milestone-first sequence

When I built the plan for my second company, I mapped it out in a way that felt almost mechanical, which turned out to be the right instinct. Every role had to pass through three gates:

  1. Milestone gate: which concrete business number does this role move in the next 6 months?
  2. Bottleneck gate: is this the specific constraint, or just a symptom of a different problem?
  3. Cost-of-delay gate: what do we lose per month if we don't hire this person?

The third gate is the one most people skip. A backend engineer and a customer success lead might both look important on paper. But if your churn is at 14% per quarter and every missed month costs you another 30 accounts, the CS hire wins. If your product is losing deals because it's missing a feature, the engineer wins. Same budget, very different sequence.

What the plan should actually contain

A solid hiring plan document is two pages, not twenty. If yours is longer, you're hiding uncertainty inside formatting. It should cover:

  • The business milestone you're hiring toward, with the number and the date.
  • Each role, its sequence position, and the fully loaded annual cost.
  • The output or deliverable that justifies each role existing.
  • Owner of the hiring process for each role (a name, not "the team").
  • Target start quarter, and a hiring-cycle assumption (typically 6-10 weeks from opening a role to someone sitting in the chair, longer for senior and technical positions).
  • The trigger that would make you cancel or delay the hire (this is the plan's kill switch, and it matters as much as the roles themselves).

What is the 70/30 rule in hiring?

The 70/30 rule says that roughly 70% of your hires should be people who have already done the job you're asking them to do, and about 30% should be stretch hires — people with more upside than track record. It's a balancing act between reducing execution risk and preserving the upside that lets a small team beat a big one.

Why those numbers? Because hiring is a portfolio problem. If 100% of your hires are proven operators, you get predictability but you cap your ceiling and you spend the next two years paying premium salaries for people who will never surprise you. If 100% are stretch hires, you get cheap energy and ambitious bets but you'll drown in execution debt, and your senior people will quit because nobody is fixing the mess.

How to apply the rule in practice

Label every role in your plan as either "proven" or "stretch" before you post it. In a 12-person company about to hire 8 more, aim for roughly 5-6 proven and 2-3 stretch. When a stretch hire fails, they usually fail fast — within 90 days — which means you can correct cheaply if you're honest about the labeling up front.

The honest failure mode I've seen: a founder labels every hire as "stretch" because it flatters the culture ("we hire for slope, not experience") and then discovers that stretch hires need more management than a first-time founder has time to provide. Those hires don't fail from lack of talent. They fail from lack of scaffolding.

What are the 5 C's of hiring?

The 5 C's of hiring are the five dimensions most often used to evaluate a candidate: competence, character, culture fit, commitment, and compensation alignment. Some versions of the framework swap in "communication" or "capacity" for one of these — the exact list varies, but the underlying idea is stable: you're not evaluating one trait, you're evaluating five, and weak signals on any one of them tend to predict a bad hire.

How to score the five dimensions

Score each candidate on the 5 C's on a 1-5 scale, and don't fudge the scores to "make the hire work." A candidate scoring 5 on competence and 2 on commitment (say, they're interviewing at three other companies and hinting they'd leave in a year) is not a good hire, no matter how good the interview felt.

C What you're actually checking Quick test
Competence Have they done this specific job at this scale? Ask for two concrete examples with numbers.
Character How do they behave under pressure or disagreement? Ask about a mistake they made and what changed after.
Culture fit Do their defaults match how you actually operate? Ask what a great week looks like to them.
Commitment How long a runway do they see with you? Ask what would make them leave in two years.
Compensation alignment Is the package a match for their expectations? Ask their range before you name yours.

The weakest of the five is what you should treat as the candidate's real score. A 5,5,5,2,4 candidate is a 2. That's hard to accept when you're desperate to fill a seat, but it's the honest read.

What is the 80/20 rule in recruiting?

The 80/20 rule in recruiting says that roughly 80% of your hiring outcomes come from 20% of your effort — and that 20% is almost always sourcing, not interviewing. Most founders spend 80% of their recruiting time on interviews, debriefs, and offer negotiations, and 20% on sourcing. Flip that.

What is the 80/20 rule in recruiting?

I learned this the expensive way on my first real hire. I posted a job, got 340 applications, spent three weekends screening them, and hired a candidate from that pool who lasted nine months. The next hire, I spent two weeks reaching out to people I already knew or had been referred to, interviewed six of them, and made an offer that took three days to close. That person is still with the company. Same role, same budget, wildly different process.

How to shift your recruiting spend toward sourcing

  • Build a target list of 20-40 named people before you open a role. Not applications. Names.
  • Budget two hours per week for warm outreach, starting six weeks before you need the hire.
  • Treat referrals as your highest-signal channel and ask for them specifically, at the moment someone says "great hire" about someone else.
  • Interview fewer candidates, more deeply. Six focused interviews beat thirty shallow ones almost every time.

The 80/20 rule isn't a magic formula. It's a reminder that hiring quality is upstream, not downstream.

What are the 7 stages of a startup?

The 7 startup stages are commonly described as: idea, prototype or validation, early traction, product-market fit, growth, expansion, and maturity. Each stage has a distinct hiring signature, and skipping a stage — either hiring too fast for where you are, or too slow — is the most common reason a plan goes sideways.

The hiring signature at each stage

  1. Idea: no hires. Founders only. Any hire you make before there's a validated problem is a hire you'll reverse.
  2. Validation: 0-2 hires, almost always generalists. Someone who can build, sell, and support in the same week.
  3. Early traction: first real sequence. One person for the bottleneck function (usually product or sales), plus a generalist operator.
  4. Product-market fit: first specialist hires. This is where the 70/30 rule starts mattering — you're no longer guessing, so you can hire people who've done the job before.
  5. Growth: function leads. Engineering lead, sales lead, head of marketing. Headcount roughly doubles, sometimes more.
  6. Expansion: second-layer management, and the first hires who manage managers. This is where most plans become unrealistic, because managers of managers are expensive and slow to hire.
  7. Maturity: efficiency hires. The plan shifts from "who do we add" to "who do we restructure around."

Each stage shifts the 70/30 balance, too. Stages 1-3 lean heavily toward generalists (closer to 50/50 or even 40/60). Stages 4-5 push toward 70/30. Stage 6 starts pulling back toward generalists again, but seasoned ones — leaders who can run teams they didn't build.

Modeling the real cost before you hire

A salary is not the cost of a hire. The real number is what you should be modeling in your plan, and it's typically much higher than founders expect. On top of base salary you're covering employer taxes and benefits, tools and equipment, recruiter or referral fees if you use them, and — the number nobody puts in the deck — the ramp time before the person is contributing at full capacity. For most roles, that ramp is 2-4 months. For senior roles and technical hires, it's often 4-6.

So if you're planning a $140K salary hire, budget for roughly $190-210K in year one fully loaded, spread unevenly across the year because of the ramp. That changes the sequence, doesn't it? It's the single most common reason a hiring plan that looked affordable in the board deck is quietly 25% over budget by month nine.

What to do when the plan breaks — because it will

Every plan I've built has broken within six months. Revenue comes in faster than expected, or slower. A key hire falls through. A competitor launches something that changes the priority. The plan that survives is the one with a pre-agreed response, not the one that was perfect on day one.

My own fix, after getting this wrong twice: I now write a "if X, then Y" line into every quarterly plan. If revenue comes in 20% below plan, we pause hires 3 and 4 and accelerate hire 2. If revenue comes in 20% above plan, we do the inverse. The rule is set in the calm before the year starts, so the decision doesn't have to be made in a panic.

The other thing I do — and this one took me an embarrassingly long time to learn — is review the plan against actual headcount every quarter, out loud, with the team that has to execute it. Half the time the plan is fine. The other half, someone in the room points out a role that nobody actually needs yet, and the buffer you freed up pays for the role you didn't know you needed. A hiring plan isn't a document you write and file. It's a conversation you have to keep having, quarterly, with the numbers in front of you, and with the discipline to name the bottleneck out loud instead of hiring toward the loudest complaint.

One last thing. When you look back on the hires you've made — the ones you'd make again in a heartbeat and the ones you wouldn't — the difference is rarely the candidate. It's usually whether you knew, before you posted the role, what the person was really supposed to change.