82. Early Hiring

Early hiring is not about filling an org chart. It is about removing the most important bottleneck in the company.

The first hires define the operating standard. They affect speed, culture, customer quality, product quality, and founder leverage. A great early hire makes the company feel lighter. A wrong early hire consumes founder time, confuses priorities, and lowers the bar.

Hire slowly enough to be clear, but not so slowly that founders become the bottleneck for everything.

The core early hiring question is: which hire removes the most important company bottleneck in the next 90 days without creating more confusion, payroll pressure, or management load than the startup can handle?

Hiring Is A Constraint Decision

Every early hire should be tied to a constraint.

Use this sequence:

1. Name the company bottleneck.
2. Decide whether it is a skill, time, process, or clarity problem.
3. Try focus, tools, contractors, or better process if those are enough.
4. Hire only when a full-time person creates leverage.
5. Define the first 90-day outcomes before sourcing.

Bad reason to hire:

“We need a marketing person because other startups have one.”

Better reason:

“Founder-led sales is producing customer language and repeat objections, but no one is turning that into weekly content, website messaging, and sales collateral. A product marketer can convert learning into demand and sales leverage.”

Hiring should make the company more focused, not merely larger.

First hires

Engineer

Hire engineering early when product speed, reliability, or technical depth is the main bottleneck.

Look for:

• Ability to ship independently
• Product sense
• Debugging ability
• Low ego
• Good judgment about shortcuts
• Comfort with ambiguity

Avoid hiring someone who needs a large team, detailed specs, and perfect process to move.

Early engineering hires should be comfortable with product ambiguity. They may need to speak with customers, read support tickets, make pragmatic architecture tradeoffs, and ship small improvements without a PM translating everything.

Good interview signal:

• Can explain tradeoffs without jargon.
• Has shipped messy v1 products.
• Notices product risk, not only code risk.
• Writes enough documentation for others to follow.
• Knows when not to over-engineer.

Designer

Hire design early when product clarity, onboarding, trust, and workflow quality matter.

Early design is not decoration. It helps users understand value faster and reduces support burden.

Look for someone who can work from messy customer insight, not only polished briefs.

The first designer may need to own:

• Onboarding clarity.
• Trust and credibility.
• Workflow simplification.
• Landing page or sales collateral.
• User research synthesis.
• Design system basics.

Do not hire a pure visual designer if the real need is product workflow thinking.

Sales

Hire sales after founders have learned enough to teach the motion.

Good signs:

• Clear target segment
• Repeat objections
• Repeat demo flow
• Some closed deals
• Known pricing range
• A real pipeline

If the founder has not sold at all, a salesperson may inherit confusion.

The first sales hire is usually not a VP Sales. Early on, you often need a founder-led sales associate, SDR-like researcher, account executive with startup range, or sales ops generalist.

Before hiring, document:

• ICP.
• Outreach message.
• Discovery questions.
• Demo flow.
• Pricing range.
• Objections.
• CRM stages.
• What founder still owns.

If this documentation does not exist, the first sales hire will either invent a motion or get blamed for founder confusion.

Support

Hire support when customer questions, onboarding, and issue resolution are taking too much founder or engineering time.

Support in an early startup is also product research. The person should document repeated issues and help improve onboarding.

Support hires should not merely “handle tickets.” They should create a loop:

Customer issue -> support response -> root cause -> product/process fix -> fewer repeated issues

If support volume is rising because onboarding is broken, fix onboarding too. Do not hire support to absorb avoidable confusion forever.

Operations

Operations hires are valuable when manual work is blocking growth.

Examples:

• Customer onboarding
• Vendor coordination
• Field execution
• Data cleanup
• Finance follow-up
• Process documentation

Great ops hires bring order without creating bureaucracy.

The best early ops people are systems builders. They make repeated work visible, reliable, and eventually automatable.

Look for:

• Detail orientation.
• Calm execution.
• Comfort with spreadsheets and tools.
• Customer/vendor communication.
• Process writing.
• Follow-through.
• Ability to improve a system, not just run it.

Marketing

Hire marketing when you know what message, segment, or channel needs consistent execution.

Early marketing can mean content, positioning, product marketing, demand generation, community, or lifecycle. Be clear which one you need.

Do not hire “marketing” as a generic cure. Choose the actual job:

Need	Better role
Website and sales messaging unclear	Product marketer / positioning
Founder has insights but no publishing rhythm	Content marketer
Need experiments across channels	Growth generalist
Community-led category	Community/operator marketer
Existing demand but poor conversion	Lifecycle or conversion marketer
Sales team needs collateral	Product marketing / sales enablement

One person rarely excels at all of these.

Generalist

A strong generalist can be powerful early.

Use generalists for:

• Research
• Ops
• Founder leverage
• Customer follow-up
• Content coordination
• Special projects
• Internal systems

But do not use “generalist” as a way to avoid defining work.

Founder’s associate

A founder’s associate can create leverage if the founder already knows what to delegate.

Good uses:

• Research
• Hiring coordination
• Investor updates
• Customer notes
• Internal dashboards
• Special projects

Bad use: hiring someone to absorb founder chaos without clear priorities.

A founder’s associate works best when the founder has a strong operating rhythm. If the founder changes priorities every day, the associate becomes a human buffer for confusion.

Good first projects:

• Build investor update process.
• Turn customer calls into structured notes.
• Create recruiting tracker.
• Own competitive research.
• Coordinate weekly operating review.
• Document internal workflows.

Bad first project:

“Help me with whatever comes up.”

Hiring timing

Bottleneck hiring

Hire for the bottleneck.

Ask:

• What is slowing the company most?
• Is it lack of skill, time, process, or clarity?
• Can software, contractors, or focus solve it first?
• Will this hire create leverage within 90 days?

Hiring should remove a constraint, not create a new management job.

Use this bottleneck table:

Bottleneck	Hire may help if	Hiring may not help if
Product shipping slow	Scope is clear and founder/lead can manage engineering	Product direction changes daily
Sales pipeline weak	ICP and sales motion have some founder proof	Founder has avoided sales
Customers confused	Support/onboarding issues repeat	Product value is unclear
Founder overloaded	Repeatable tasks can be delegated	Founder cannot prioritize
Marketing absent	Message and segment are reasonably clear	You do not know who buys
Ops messy	Work repeats and quality matters	Every request is custom

Revenue before hiring

Revenue is not always required before hiring, especially for funded or deep-tech startups. But revenue or strong validation should guide customer-facing hires.

Do not build a big sales or marketing team before knowing who buys and why.

Product before hiring

If the product is not yet usable, hiring growth roles may create pressure without conversion. If the product is useful but founders are overloaded, hiring product, engineering, or support can unlock growth.

Founder time leverage

A hire is valuable if it moves founder time from repeatable work to high-leverage work.

High-leverage founder work:

• Customer discovery
• Product direction
• Key sales
• Hiring
• Fundraising
• Strategy
• Culture

Before hiring, list what the founder will stop doing after the hire joins. If nothing meaningful changes, the role may not create leverage.

Example:

After hiring customer ops, the founder stops manually chasing onboarding documents, setting up every customer workspace, and answering repeated setup questions. Founder still owns enterprise onboarding calls and product feedback synthesis.

Clear delegation protects both founder and hire.

Hiring too early

Hiring too early creates payroll pressure and management overhead before work is clear.

Warning signs:

• Role is vague
• Founder cannot define success
• There is not enough work
• Product direction changes weekly
• You are hiring because you feel behind

Another warning sign: you are hiring to avoid doing work you have not learned yourself. For founder-led sales, customer discovery, early product support, and first customer onboarding, the founder often needs to do the work before delegating it.

Hiring too late

Hiring too late creates founder burnout and slows the company.

Warning signs:

• Founders repeat the same task every week
• Customers wait too long
• Product quality drops
• Hiring pipeline is always urgent
• Good opportunities are missed

Hiring too late can look financially disciplined while quietly damaging the company. Founder burnout, slow customer response, and quality drops can cost more than a carefully timed hire.

First 90 Days

Every early hire needs a 30/60/90 plan.

Period	Goal
First 30 days	Learn customer, product, tools, expectations; deliver small visible wins
First 60 days	Own a defined workflow or output with decreasing founder involvement
First 90 days	Improve the system, not just execute tasks

Write this before the offer. It will improve hiring, onboarding, and performance conversations.

Example for first support hire:

Period	Outcome
30 days	Understand top 20 support issues, write help docs for top 5, respond with founder review
60 days	Own daily support inbox, create weekly issue report, reduce repeated questions
90 days	Improve onboarding checklist, cut setup time by 30 percent, escalate product fixes

Contractor vs Full-Time

Not every need requires a full-time hire.

Use contractors when:

• The work is project-based.
• You do not yet know the full-time role.
• The skill is specialized but occasional.
• You need speed without long-term payroll.

Use full-time when:

• The work is core and recurring.
• Context compounds.
• Ownership matters.
• Customer or product learning must stay inside the company.
• The person can create leverage beyond tasks.

Examples:

• Logo redesign: contractor may be fine.
• Core product engineering: usually full-time.
• One-off compliance setup: specialist advisor.
• Customer onboarding and support loop: often full-time when volume repeats.

Hiring mistakes

Hiring big-company people too early

Big-company experience can be valuable, but early startups need builders.

Ask candidates:

• What have you built from zero?
• When did you work without support functions?
• How do you handle ambiguity?
• What do you do when no process exists?

Big-company people can be excellent if they have builder muscle. The question is not company brand. The question is whether they can operate without the support system they had before.

Hiring for resume

A famous company on a resume does not guarantee startup fit.

Evaluate the actual work, judgment, speed, ownership, and motivation.

No work trial

Use work samples or trials when possible.

Examples:

• Engineer fixes a small bug or designs a system
• Sales candidate runs discovery role-play
• Marketer writes a positioning brief
• Ops candidate creates a process plan
• Designer improves onboarding flow

Pay for substantial work trials when appropriate.

Vague role

If you cannot define the role, do not hire yet.

Write:

• Mission
• First 90-day outcomes
• Key responsibilities
• Success metrics
• Required strengths
• What this role will not own

No onboarding

Early employees need context:

• Customer
• Product
• Market
• Current priorities
• Decision principles
• Tools
• Working norms

Do not expect smart people to read the founder’s mind.

Create an onboarding packet:

• Company one-liner.
• Current strategy.
• Customer/persona notes.
• Product walkthrough.
• Team norms.
• Tools and access.
• Decision principles.
• Current roadmap or operating priorities.
• Role success plan.
• Key documents.

This is lightweight, but it saves weeks of repeated explanation.

No performance expectations

Set expectations early. Kindness without clarity becomes unfair.

Define what good looks like in 30, 60, and 90 days.

Too many managers too soon

Early startups usually need hands-on builders before layers of management.

Hire managers when coordination, coaching, and accountability are real bottlenecks.

The India angle

Hiring in India has specific realities:

• Notice periods can be long.
• Compensation expectations vary widely.
• Candidates may optimize for brand and stability.
• Families may influence risk decisions.
• ESOP understanding is often low.
• Remote and office expectations differ by city and role.
• Strong talent may have global options.

Founders must sell the opportunity honestly. Do not oversell certainty. Explain risk, learning, ownership, and upside clearly.

India-specific hiring timing issues:

• Notice periods can make “urgent” roles take 30-90 days.
• Buyouts can be expensive and should be used carefully.
• Candidates may need family confidence around startup risk.
• ESOPs may not be valued unless explained.
• Remote talent may have global salary expectations.
• Some candidates expect manager titles early; avoid title inflation.
• Strong candidates may compare you with funded startups, large tech, services companies, or overseas remote roles.

Plan hiring ahead of need. If you start only when the founder is already drowning, the notice period will feel brutal.

Role Sequencing By Bottleneck

Hire against the company bottleneck, not against a generic startup org chart.

Bottleneck	Likely hire	Warning
Product cannot ship fast enough	Engineer, product engineer, designer-engineer	Do not hire product managers before product work exists.
Founder cannot sell enough qualified deals	Sales development, founder’s associate, first sales hire	Do not outsource market discovery too early.
Customers churn during setup	Customer success or implementation	Do not call support a “nice to have” if activation is the business.
Manual ops block growth	Operations generalist	Do not automate chaos before understanding the workflow.
Founder calendar is fragmented	Founder associate or chief-of-staff type	Do not hire this before the founder has clear priorities.
Marketing has proven one channel	Content, performance, community, or lifecycle specialist	Do not hire a generic marketer to discover all channels.

The question is: “What is the highest-leverage human bottleneck now?” A great hire in the wrong sequence still burns runway.

Hiring ROI Test

Before opening a role, write the expected return.

If this hire works, then within 90 days:
- [metric/workflow] improves from X to Y
- founder time reduces by X hours/week
- customer/revenue/product speed improves because...
- the company learns whether...

Then write the failure version:

If this hire fails, we will know because:
- output is missing by week 4
- founder support required stays too high
- customer/team feedback shows...
- the bottleneck has not changed

This prevents vague hiring. A role should change the operating system, not merely reduce founder anxiety.

First Hire Onboarding Plan

Early employees do not join a finished company. They need context.

Create a first-week onboarding plan:

• Company story and current strategy.
• Customer/persona explanation.
• Product walkthrough.
• Current metrics and runway context at the right level.
• Role outcomes for 30, 60, and 90 days.
• Decision rights.
• Communication norms.
• How to ask for help.
• What not to touch yet.
• First small win.

The first small win matters. It builds confidence and reveals whether the person can operate in startup ambiguity.

Hiring Sequence Decision Table

Early hiring should follow bottlenecks, not fashion. Use this decision table before opening a role.

If the company is stuck because…	Consider hiring…	Do not hire yet if…
Founders cannot ship the core product.	Product engineer, full-stack engineer, designer-engineer.	The product direction changes every week.
Users try the product but fail to activate.	Implementation/customer success owner.	The onboarding problem is still unknown.
Founder-led sales has proven the ICP but founder time is capped.	SDR, sales generalist, founder’s associate.	The founder has not closed repeatable deals personally.
Customers need repeated support and support quality affects retention.	Support/CS generalist.	Support is actually product confusion that should be fixed.
Operations are manual but repeatable.	Operations generalist.	The workflow changes for every customer.
One channel is working and needs consistency.	Channel-specific marketer.	You still do not know which channel works.
Founder is fragmented across admin, research, hiring, and follow-up.	Founder associate.	The founder cannot delegate clearly.

The table is deliberately conservative. Hiring is a commitment, not a productivity hack.

The Role Sharpness Test

Before hiring, answer these:

• What will this person own that nobody owns today?
• Which founder bottleneck will reduce?
• What should improve in 30 days?
• What should improve in 90 days?
• What decision rights will they have?
• What support will they need from the founder?
• What will we stop doing if this hire does not happen?

If the answers are vague, the role is vague. Vague roles attract mismatched candidates and create performance confusion.

First-Hire Failure Modes

Watch for:

• Hiring a senior person who needs a team before they can operate.
• Hiring a junior person when the company needs independent judgment.
• Hiring a specialist before the channel or workflow is proven.
• Hiring a manager before there is enough execution work to manage.
• Hiring for prestige because customers or investors will be impressed.
• Hiring someone the founder secretly hopes will solve strategy.

The first hires should increase learning speed and execution quality. They should not become expensive substitutes for founder clarity.

Contractor, Intern, Or Full-Time?

Choose deliberately:

Mode	Useful when	Risk
Contractor	Scope is defined, temporary, or specialist.	Low ownership if the work needs deep context.
Intern	Work is structured and mentorship exists.	Can become cheap labor without leverage.
Full-time generalist	Work is broad, recurring, and context-heavy.	Needs strong onboarding and founder attention.
Full-time specialist	Function is proven and workload is steady.	Too early if the function is still being discovered.

Do not use interns to solve founder ambiguity. Do not use contractors for work that requires company-level ownership unless scope and expectations are very clear.

Reader action

Before opening a role, write a one-page hiring brief:

• Why now?
• Bottleneck this role removes
• First 90-day outcomes
• Must-have skills
• Must-have behaviors
• Interview process
• Work sample
• Compensation range
• Reporting owner

If the brief is vague, the hire will be vague.

Add one more line to the brief:

What will become faster, better, or less founder-dependent 90 days after this person joins?

If you cannot answer that, wait.

First 90 Days For A New Hire

Hiring does not end when the offer is accepted. Early hires need a clear 90-day ramp because the company has little structure and much of the context is inside founders’ heads.

Use this plan:

Period	Founder responsibility	New hire outcome
Before joining	Share company context, role brief, first-week plan, and what success means.	Candidate arrives with realistic expectations.
Week 1	Explain customer, product, runway context, working norms, and current priorities.	Understands the company and completes one small useful win.
Days 8-30	Pair on real work, give fast feedback, clarify decision rights.	Owns a small workflow or deliverable independently.
Days 31-60	Increase ownership, expose them to customers/users/internal metrics.	Produces visible output without founder micromanagement.
Days 61-90	Review role fit, performance, scope, support needs, and compensation expectations if relevant.	Clear continue, adjust, or exit decision.

The first 90 days should answer three questions:

• Can this person do the work?
• Can this person operate in our level of ambiguity?
• Does the company know how to use this person well?

If the answer is unclear after 90 days, the founder probably did not define the role sharply enough.

First 30-Day Output Map

Every early hire should have a concrete first-month output map.

Examples:

Role	First 30-day output
Engineer	Ship one production improvement and write notes on codebase risks.
Designer	Improve one core flow and document design gaps.
Sales hire	Build target account list, run discovery calls with founder, write objection notes.
Customer success	Map onboarding failure points and improve one activation step.
Operations generalist	Document one repeated workflow and remove one manual bottleneck.
Marketing hire	Publish/test one channel asset and report learning, not vanity metrics.
Founder associate	Turn one messy founder problem into a decision memo and operating tracker.

Early output should be small enough to complete and real enough to reveal quality.

Candidate Evaluation Scorecard

Do not hire only from interview feeling. Score the candidate against the job the company actually needs.

Area	What to look for	Evidence source
Skill fit	Can do the core work required in the next 90 days.	Work sample, past work, trial task.
Stage fit	Comfortable with ambiguity, imperfect process, and changing context.	Startup examples, reference checks, scenario questions.
Ownership	Takes responsibility without waiting for perfect instructions.	Work history, trial task, manager references.
Customer proximity	Can understand users, buyers, support issues, or market reality.	Interview role play, customer examples.
Judgment	Makes sensible tradeoffs for startup stage.	Case discussion and prior decisions.
Communication	Writes and speaks clearly, especially when blocked.	Emails, work sample, interview follow-up.
Pace	Moves fast without creating avoidable mess.	Trial task timing and prior shipping examples.
Values	Raises the bar without ego or politics.	References and behavioral examples.

Use a simple 1-5 score. A candidate with a famous company name but weak stage fit may fail. A less polished candidate with high ownership and relevant customer sense may be excellent.

Work Sample Design

A good work sample should be close to the job:

Role	Useful work sample
Engineer	Debug or extend a small product workflow with a written tradeoff note.
Designer	Redesign one onboarding or trust flow using messy customer context.
Sales	Research 10 target accounts and write first-touch messages with reasoning.
Marketing	Turn customer notes into positioning, page copy, or a content brief.
Operations	Turn a messy repeated process into a tracker and SOP.
Customer success	Diagnose onboarding friction and write an activation plan.
Founder associate	Convert an ambiguous founder problem into a decision memo.

Respect candidate time. Keep the sample bounded, explain evaluation criteria, and avoid asking for unpaid production work disguised as assessment.

First-Hire Operating Cadence

Early hires need rhythm because the company does not yet have mature management systems.

Use this cadence:

Cadence	Purpose
Daily first-week check-in	Remove confusion quickly.
Weekly 1:1	Review priorities, blockers, feedback, and decisions needed.
Weekly output review	Look at shipped work, not activity.
Monthly role review	Check whether the role still matches company bottleneck.
30/60/90 review	Decide continue, adjust scope, add support, or exit.

The founder should not micromanage every action, but the founder must supply context, feedback, and decision rights. Early hires cannot read the founder’s mind.

Warning Signs In The First 30 Days

Act early if you see:

• The hire waits passively for exact tasks.
• The founder avoids giving direct feedback.
• Work is busy but not connected to the bottleneck.
• The hire is surprised by ambiguity despite being warned.
• The role keeps changing because founder priorities are unclear.
• The hire hides confusion to look competent.
• The team cannot explain what the person owns.

Many early hiring failures are mutual design failures. Fix role clarity first. If ownership, judgment, or integrity is missing, act faster.

Hiring Kill Criteria

Before opening a role, write when you will stop the search.

Stop or redesign the search if:

• Strong candidates do not understand the role after explanation.
• Every good candidate says the title and work do not match.
• Compensation is far below the market for the risk.
• Work samples reveal that the role needs a different skill.
• The founder keeps changing what the person should own.
• The company cannot onboard the role properly.

Stopping a bad search is not failure. It is cheaper than hiring someone into confusion.

Hiring Portfolio By Stage

Think of early hiring as a portfolio of risk reduction, not a collection of job titles.

Stage	Primary risk	Best hire type	Dangerous hire type
Idea/discovery	Wrong problem or customer	Founder-led interviews, domain advisor, temporary researcher	Full team before customer proof
MVP	Slow product learning	Engineer/designer/generalist who can ship small loops	Specialist who needs mature specs
First customers	Founder cannot handle delivery/sales/support	Customer success, operations, sales-support generalist	Pure manager with no hands-on work
Repeatability	Motion exists but is founder-dependent	Sales, growth, onboarding, product ops	Senior leader without a working system
Scaling	Systems and team complexity	Functional leads and managers	More individual contributors without coordination

Before opening a role, write which risk the hire reduces. If the answer is “the founder is tired,” pause. The founder may need focus, delegation, or process before a hire.

Role Compression And Expansion

Early roles are often compressed: one person does work that later becomes three roles. Be honest about that.

Compressed role	What it may include now	What it may split into later
Founding engineer	Product engineering, infrastructure, support debugging, technical tradeoffs	Frontend, backend, platform, engineering manager
Growth/marketing generalist	Content, landing pages, analytics, outreach, partnerships	Demand gen, content, product marketing, growth ops
Customer success/operator	Onboarding, support, documentation, manual workflows, feedback loops	CS, implementation, support, operations
Founder associate	Research, ops, hiring, investor prep, special projects	BizOps, chief of staff, analyst, operations
Sales generalist	Prospecting, discovery, CRM, follow-up, proposal support	SDR, AE, sales ops, partnerships

Tell candidates the truth: “This role is broad now. If we grow, it may either expand into leadership or split into a narrower specialty. We will review it every 90 days.”

This avoids a common mismatch: the company wants a high-ownership generalist, while the candidate expects a stable functional lane.

First Hiring Retrospective

After every early hire, run a retrospective 30 days after joining.

Question	Answer
Was the role defined around the right bottleneck?
Did our sourcing produce the right candidates?
Did the work sample predict real work?
What surprised the new hire?
What context did we fail to share?
What did the founder still keep control of unnecessarily?
Should the scorecard change before the next hire?

Early hiring should improve the company’s hiring system. If every new hire teaches nothing about the process, the founder is repeating mistakes with more people.

Hire Or Redesign Decision Gate

Before opening a role, ask whether the company truly needs a hire or whether the bottleneck is actually unclear priority, weak process, poor delegation, founder avoidance, or tooling.

Use this gate:

Question	If yes	If no
Is the bottleneck repeated for at least 4-6 weeks?	A role may be justified.	Fix prioritization before hiring.
Does the work map to a clear outcome?	Write the 90-day success definition.	Redesign the work before writing a JD.
Can the founder explain what good looks like?	Create scorecard and work sample.	Founder must learn the function or get an advisor first.
Is there enough work for one person?	Hire full-time or long-term contractor.	Use project help, agency, tool, or founder focus.
Will this hire increase speed within 90 days?	Proceed if onboarding is ready.	The role may be too senior, too vague, or too early.
Can the company support the hire?	Assign manager, context, tools, and decisions.	Do not hire someone into a vacuum.
Is the compensation affordable for 12 months?	Move to recruiting.	Adjust scope, timing, or funding plan.

If the gate fails, do not call that discipline “delaying hiring.” Call it protecting the next person from an unclear role.

The best early hires enter a company where the founder knows the bottleneck, the outcome, the decision rights, and the support plan. Hiring into confusion usually turns one founder problem into two people problems.

First Five Hires Map

The first five hires should not be chosen from a generic startup template. They should reflect the company’s real constraint.

Use this map before making early offers:

Hire slot	Bottleneck being removed	Role shape	90-day result	Risk if wrong
Hire 1
Hire 2
Hire 3
Hire 4
Hire 5

For each hire, write the sentence:

We are hiring [role] because [specific bottleneck] is preventing [company outcome], and this person should produce [90-day evidence].

Examples:

Bad hiring sentence	Better hiring sentence
We need a marketer.	We need a content/product marketing generalist because founder calls are revealing repeat language, but we are not converting that into website, sales collateral, and weekly publishing.
We need more engineers.	We need one product engineer because customer onboarding issues are blocking activation and the founder cannot ship fixes fast enough.
We need operations.	We need an implementation operator because every new customer requires manual setup and founder-led onboarding is limiting sales capacity.
We need a sales person.	We need a sales development/research hire because the founder can close warm calls but cannot build enough qualified pipeline every week.

The first five hires usually need high ownership, low ego, and comfort with changing scope. They should not need mature departments around them.

Hire sequencing rule

Sequence hires by constraint, not by function prestige.

Ask:

• What would break if we doubled customers next month?
• What work is only the founder doing that someone else could do 70 percent as well?
• What work requires founder judgment and should not be delegated yet?
• What repeated customer pain can be solved by one focused owner?
• What hire would create more management work than leverage?
• What hire would make the next two hires easier?

Avoid hiring ahead of learning. A sales leader before a repeatable motion, a marketing leader before clear positioning, or a VP-level operator before messy execution is understood can slow the company down.

India early-hiring note

Indian founders often face long notice periods, family-risk concerns, and candidate questions about cash stability. Start searches earlier than you think, but do not lower the bar because someone can join quickly. Joining speed is useful; stage fit is more useful.

For critical hires, prepare:

• Runway explanation.
• Role scope and expected ambiguity.
• Founder availability for onboarding.
• ESOP explanation in plain language.
• Why the company is worth the career risk.
• What will be true in 90 days if the hire succeeds.

Early hiring is not only evaluation. It is also trust-building with people who are taking a real risk on your company.

Role Success Contract

Before opening a role, write a one-page success contract. This prevents vague hiring and vague onboarding.

Field	Answer
Role
Company constraint this role solves
First 30-day outcome
First 60-day outcome
First 90-day outcome
Decisions this person can make
Decisions they cannot make yet
Support they need from founders
Evidence of success
Reasons we should not hire this role yet

If the founder cannot fill this table, the role is not ready. Hire for a constraint, not for a title.

Trial Project Design

A good trial project tests the real work without abusing the candidate’s time. It should be narrow, relevant, and respectful.

Role type	Useful trial
Engineer	Fix a small scoped issue or explain architecture tradeoffs from a real-ish spec.
Designer	Improve one existing flow and explain assumptions.
Sales	Write a prospecting sequence and discovery plan for a real ICP.
Marketing	Create a positioning note and first campaign outline.
Operations	Turn a messy process into checklist, owner map, and exception flow.
Customer success	Diagnose onboarding friction from notes and write a customer follow-up.

Evaluate judgment, clarity, speed, quality, questions asked, and ability to work with ambiguity. Do not use a trial to get free work. Use it to reduce hiring risk.

First Hire Failure Signals

Early hires fail for different reasons than big-company hires. Watch for signals in the first 30 days:

Signal	Possible meaning
Waits for perfect instructions	Not comfortable with ambiguity.
Produces activity but no visible output	Needs tighter scope or may not be execution-fit.
Avoids customers or messy details	May be too abstract for early stage.
Needs founder approval for every small decision	Decision rights are unclear or ownership is weak.
Rejects scrappy work as “not my role”	Poor fit for stage.
Works hard but on the wrong things	Onboarding and priorities are unclear.

Do not wait six months to address these. Early correction is kinder than delayed disappointment.

Hiring Capacity Budget

Every hire consumes founder capacity before they create leverage. Early teams should budget management time as carefully as cash.

Before hiring, estimate:

Capacity item	Founder question
Role clarity	Can we explain what this person owns in one page?
Onboarding	Who will teach context, standards, customers, and tools?
Review cadence	Who will review work weekly and unblock decisions?
Feedback	Who will give direct feedback in the first 30 days?
Systems	Are there enough docs, processes, and examples for the person to work?
Founder interruption	How much founder time will this role need before it saves time?
Failure cost	What happens if this hire is wrong?

Hiring too early often means the founder is trying to buy relief. The better question is whether the company can absorb the hire.

Capacity Rule

If a founder cannot spend meaningful time with a critical early hire in the first 30 days, the hire is at risk. A talented person can still fail when context, priorities, and feedback are missing.

Role Before Person Checklist

Founders often meet an impressive candidate and then invent a role around them. Sometimes this works, but it is risky.

Write the role before falling in love with the person:

Role name:
Company bottleneck this role solves:
First 90-day outcomes:
Decisions this person can make:
Skills required now:
Skills that can be learned later:
Manager/founder owner:
What this role is not:
Failure signals:

Then compare the candidate to the role. If the role changes because of the candidate, write why.

This protects the company from hiring for charisma, pedigree, or anxiety. Early hiring should reduce a real bottleneck, not decorate the team page.

Hiring Sequence Review

Every month, review whether the next hire is still the right hire. Startup priorities change quickly, and a role that was urgent six weeks ago may no longer be the highest-leverage hire.

Use this review:

Question	Answer
What is the biggest company bottleneck now?
Is the bottleneck skill, capacity, process, product, sales, or founder focus?
Can the bottleneck be solved by redesigning work before hiring?
Which role would remove the bottleneck fastest?
Who will manage and onboard this person?
What 90-day outcome proves the hire worked?
What hiring plan should be paused?

This review prevents a common early-stage mistake: continuing to recruit for yesterday’s bottleneck because the process already started.

Hiring no-go signals

Pause or redesign the role when:

Signal	Meaning
Founder cannot write first 90-day outcomes	Role is vague.
No one can manage the person	Hire may create more work than leverage.
Runway is tight and outcome is indirect	Cash risk may be too high.
Candidate needs structure the company cannot provide	Stage mismatch.
Role exists because founder is avoiding sales, customer support, or hard prioritization	Founder behavior, not headcount, is the problem.
Multiple roles feel equally urgent	Company needs prioritization before recruiting.

Not hiring can be a strong operating decision. It frees attention for the bottleneck that actually matters.

Early Hire Reference Questions

References should test stage fit, not only competence.

Ask:

Question	What it reveals
What kind of ambiguity did this person handle well?	Early-stage comfort.
Where did they need structure or support?	Onboarding and management needs.
How did they respond when priorities changed?	Startup adaptability.
How did they handle direct feedback?	Coachability.
What work gave them energy?	Role fit.
What should we not put them in charge of too early?	Risk areas.
Would you hire them for a team under 20 people? Why or why not?	Stage-specific fit.

The final question matters. Someone can be excellent and still wrong for the current stage.

First 30 Days Onboarding Plan

The first hire should not spend the first month guessing what matters. Create a 30-day onboarding plan before they join.

Week	Founder responsibility	Hire outcome
Week 1	Explain company context, customers, product, current constraints, and decision rights.	Understand why the company exists, what is urgent, and how work is judged.
Week 2	Pair on real customer, product, sales, support, or operating work.	Produce first visible output with founder feedback.
Week 3	Give one owned problem with clear boundaries.	Make decisions, surface tradeoffs, and deliver a small end-to-end result.
Week 4	Review output, pace, judgment, collaboration, and support needs.	Agree 60-day outcomes and what autonomy expands next.

Use this 30-day review:

What did they ship or improve?
Where did they show ownership?
Where did ambiguity slow them down?
What context was missing?
What should they own next?
What should founders change in onboarding?

Early hires do not only fail because they are weak. They fail because the company gives them fog, no feedback, and then judges them for not reading the founder’s mind.

Related links

• 81. Co-Founders
• 83. Recruiting
• 84. Culture
• 143. Hiring First Employee Playbook
• 150. Hiring Templates