Most companies waste real money on the wrong hire because they match a person to a salary band instead of to a role. You interview someone with five years of React experience for a backend API job. You hire a junior full-stack person when you need a senior frontend specialist. The result is slow delivery, technical debt, frustrated teams, and burnt runway.
I have hired and managed developers across every common role — frontend, backend, full stack, React, Node.js, PHP — across 250 plus projects in 17 years. I have also been the senior engineer cleaning up after a bad hire, which is its own form of professional education. The U.S. Bureau of Labor Statistics Occupational Employment and Wage Statistics for software developers gives a useful baseline for the ranges in this guide; everything else is field-tested.
This is one place to figure out which role you actually need, what good looks like in an interview, what 2026 rates look like, and when a generalist beats a specialist (and when it absolutely does not). The Stack Overflow Developer Survey provides cross-checking data on language usage and compensation; I treat it as one input alongside direct hiring experience.
TL;DR
- Frontend developers own UI, interactivity, and user experience. Hire them for complex interfaces, real-time interactions, or single-page applications. Expect $40K to $180K (junior to senior).
- Backend developers own databases, APIs, scalability, and business logic. Hire them for APIs, microservices, data pipelines, or performance-critical systems. Expect $50K to $200K plus.
- Full-stack developers build end-to-end features. Best for early-stage startups, MVPs, and small teams where flexibility beats depth. Expect $45K to $190K.
- Framework specialists (React, Node.js, PHP) are worth the premium when you have committed to a stack. Their depth in one tool beats generalists for complex features.
- Common hiring mistakes: confusing seniority with role fit, underestimating specialty needs, hiring the wrong type for your stage, and skipping technical assessments.
Table of contents
- Role-specific skills matrix
- Developer rates by role and seniority in 2026
- Frontend developer hiring guide
- Backend developer hiring guide
- Full-stack developer hiring guide
- Framework specialists: React, Node.js, PHP
- Interview questions by role
- Project type to recommended role
- Specialist vs generalist: when to hire each
- Common hiring mistakes by role
- FAQ
- Reflecting on the hires that actually paid off
Role-specific skills matrix
The matrix below compares technical depth, breadth, compensation, and best-fit context for each role. Use it to benchmark candidates against the work you actually have.
| Skill / dimension | Frontend | Backend | Full stack | React/Vue/Angular specialist | Node.js specialist |
|---|---|---|---|---|---|
| Core focus | UI, UX, interactivity, performance | APIs, databases, scaling, security | Both layers, end-to-end | Framework mastery | Node.js backend mastery |
| HTML/CSS/JS | 5/5 | 2/5 | 4/5 | 5/5 | 3/5 |
| State management | 4/5 | 2/5 | 3/5 | 5/5 | 2/5 |
| API integration | 4/5 | 5/5 | 4/5 | 4/5 | 5/5 |
| Database design | 2/5 | 5/5 | 3/5 | 2/5 | 4/5 |
| DevOps / infra | 1/5 | 4/5 | 2/5 | 1/5 | 3/5 |
| Testing | 4/5 | 5/5 | 3/5 | 4/5 | 4/5 |
| Performance optimization | 5/5 (rendering, bundles) | 5/5 (queries, caching) | 3/5 | 4/5 | 4/5 |
| Communication | 3/5 (with design / product) | 3/5 (architecture review) | 4/5 (bridges teams) | 3/5 | 2/5 |
| Salary range (US, 2026) | $40K–$180K | $50K–$200K+ | $45K–$190K | $60K–$190K | $60K–$200K+ |
| Best for | Rich UIs, real-time apps, SPAs | APIs, scaling, infra | MVPs, small teams | Heavy React/Vue codebases | JS-heavy backends |
| Onboarding | 2–4 weeks | 4–8 weeks | 3–6 weeks | 1–2 weeks (stack match) | 1–2 weeks (stack match) |
What the matrix tells you
Backend goes deep in one direction. Frontend goes wide in another. Full-stack tries to balance both and usually pays for it in depth. Framework specialists exchange breadth for ramp-up time savings on a stack you have already committed to.
A junior frontend dev can be useful in two weeks. A junior backend dev needs four to eight weeks because system context is heavier than UI context. A junior full-stack dev needs three to six weeks before they can own a feature end to end. Plan for that. Do not promise stakeholders a sprint two ramp-up.
Specialists carry a 15 to 25 percent premium because they reduce ramp time on an established stack. That premium is real cash but it is also real productivity. The question is whether the stack is established enough to justify it.
Developer rates by role and seniority in 2026
Rates vary by location, experience, freelance vs full-time, and specialization. Use this as a budgeting baseline, not a quote.
| Role | Junior (0–2 yrs) | Mid (2–5 yrs) | Senior (5+ yrs) | Notes |
|---|---|---|---|---|
| Frontend | $40K–$70K | $70K–$130K | $130K–$180K | Premiums for React/Vue depth and a strong portfolio |
| Backend | $50K–$80K | $80K–$140K | $140K–$200K+ | Highest pay for architects and database experts |
| Full stack | $45K–$75K | $75K–$135K | $135K–$190K | Premium in startup contexts |
| React specialist | $60K–$85K | $90K–$155K | $155K–$190K | 15–25% premium over generalist frontend |
| Node.js specialist | $55K–$85K | $85K–$150K | $150K–$200K+ | JS-heavy backends pay well in 2026 |
| PHP | $35K–$60K | $60K–$120K | $120K–$170K | Trails newer stacks; legacy/WordPress lower end |
| Freelance (hourly) | $25–$50 | $50–$100 | $100–$200+ | 20–30% premium per hour vs full-time equivalent |
| Contract (3–6 months) | $3K–$6K/mo | $6K–$12K/mo | $12K–$25K/mo | 30–40% premium over full-time for flexibility |
Adjusting for context
- Remote US/EU: add 10 to 15 percent. Global remote demand pulls proven seniors up.
- Startup with equity: subtract 15 to 25 percent base, add 0.25 to 2 percent equity for senior.
- Agency or staffed team: 40 to 60 percent markup over direct freelance — that buys PM, QA, infra coverage.
- LATAM, Eastern Europe, parts of Asia: 30 to 50 percent below US rates with comparable quality if you vet carefully. A $100K US senior is roughly $50K to $70K equivalent in Argentina, Poland, or Vietnam at the contractor level.
I have run engagements across the US, the UK, the EU, and Latin America. The hidden cost of cheaper geographies is not the talent; it is communication overhead and time-zone friction. Budget for it explicitly.
Frontend developer hiring guide
What a frontend developer does
Frontend developers build the parts users see and touch. HTML, CSS, JavaScript, and one of React, Vue, or Angular. They own responsive design, accessibility, performance, and integrating with backend APIs. They watch bundle size and Core Web Vitals.
What they should not own: backend APIs, database schema, server admin, or DevOps. If your job description mixes those in, you are hiring a full-stack dev with a frontend disguise.
When to hire one
- Rich UI work. Real-time updates, drag and drop, animations, complex forms.
- Heavy SPA codebase. A serious React, Vue, or Angular app needs someone who can structure components and avoid prop drilling.
- Mobile-first traffic. If most of your users are on phones, you need someone who genuinely understands mobile performance.
- Team big enough to specialize. Past about five engineers, the frontend specialist starts to pay for themselves in code quality.
- Performance-sensitive product. Page speed maps directly to conversion. Google's PageSpeed Insights is where you watch the numbers.
Frontend skills checklist
Must have:
- HTML, CSS, JavaScript (ES6+)
- One modern framework (React, Vue, or Angular)
- State management (Redux, Zustand, Jotai, or equivalent)
- Git, npm/yarn, build tools
- API integration (fetch, axios)
- Testing (Jest, React Testing Library, or framework equivalents)
Nice to have:
- TypeScript
- Accessibility (WCAG)
- Tailwind, styled-components, or design system experience
- A UI library or two
How I assess a frontend candidate
Technical interview (90 minutes). Walk through their portfolio. Why those tech choices? Where did they cut corners? Coding challenge: "build a searchable product list using this API." Watch for component design, state choices, error handling. Then a short architecture conversation: "how would you structure a 20-page React app?"
Take-home assignment (3 to 4 hours). Small feature, public API, clear acceptance criteria. Grade on organization, responsive design, test coverage, error handling — not just whether it works.
Code review exercise. Show them a real snippet (with names changed) and ask "what would you improve, why, and what is the impact?" That is the question that filters for judgment.
A strong frontend candidate scores roughly 4/5 on technical depth, 4/5 on communication, and 3/5 on backend awareness. If they are weak on backend, that is fine — they are a frontend specialist.
Backend developer hiring guide
What a backend developer does
They build the server-side logic, APIs, databases, and infra that power everything. They design for scale, optimize queries, handle authentication, manage third-party integrations, and own reliability and security. The work is invisible to users until it breaks.
When to hire one
- API-heavy product. You handle 1,000+ requests per second or have non-trivial business logic.
- Database scaling. Datasets above 100 GB, complex queries, or distributed storage.
- Microservices or event-driven architecture. You have outgrown the monolith.
- Compliance. PCI-DSS, HIPAA, GDPR. The fines for getting this wrong are large.
- High availability. 99.9 percent uptime or better. That requires caching, load balancing, failover, and a team that has actually run incidents.
I led the Payment Service at bolttech, a $1B+ unicorn, where I ran 40+ payment providers behind one API at 99.9 percent uptime. That is the work where you notice the gap between someone who can write a backend and someone who has run one at scale. See bolttech: 40+ payment integrations.
Backend skills checklist
Must have:
- One server-side language (Node.js, Python, Go, Java, C#)
- SQL — schema design, query optimization, indexing
- REST or GraphQL API design
- Authentication and authorization (JWT, OAuth, sessions)
- Testing (unit, integration, end-to-end)
- Git
Nice to have:
- Docker
- Cloud (AWS, GCP, Azure)
- Caching (Redis, Memcached)
- Message queues (RabbitMQ, Kafka)
- Performance profiling
- Microservices
How I assess a backend candidate
System design (90 minutes). "Design an API for a real-time chat app supporting one million concurrent users." I am listening for scale awareness, database choices, caching strategy, load balancing, API design. Bad sign: jumps to implementation before discussing trade-offs.
Algorithms (45 minutes). A medium LeetCode-style problem. Less important than system design, but I want to see how they reason about edge cases.
Code review and real problem. Show them an N+1 query, a missing index, or an inefficient cache. Ask what they would change.
Architecture chat. "Walk me through a system you led. What would you change today?" This is where I learn whether they can criticize their own past work.
A strong backend candidate scores 4/5 on system design, 3/5 on algorithms, and 4/5 on communication. If they are 5/5 algorithms but 2/5 system design, you are talking to a competitive programmer, not a production engineer.
Full-stack developer hiring guide
What a full-stack developer does
End-to-end feature ownership. Schema, API, frontend, deployment. They reduce handoffs and ship features faster than two specialists in a small team. They are weakest where deep specialist work is required.
When to hire one
- MVP or early stage. Speed beats specialization. One person can own a feature without coordinating across three calendars.
- Small team (under 10 engineers). No critical mass to split into frontend and backend tribes.
- Greenfield. New product, no legacy constraints, decisions still being made.
- Rapid iteration. Features ship and pivot constantly.
When not to hire one: complex backend at scale, deep frontend work (animations, accessibility at the WCAG-AA bar, Core Web Vitals tuning), or strict specialization requirements.
Skills checklist
Must have:
- Frontend: HTML, CSS, JavaScript plus React or Vue
- Backend: Node.js, Python, or Go (one is enough, two is a bonus)
- SQL plus one NoSQL option
- REST or GraphQL API design
- Git
- Testing across the stack
Nice to have:
- DevOps basics (Docker, CI/CD)
- Cloud platform familiarity
- Linux comfort
How I assess a full-stack candidate
Code review (60 minutes). A small project with frontend and backend code. "What would you change, why, what trade-offs?" Red flag: they trash one side of the stack. "Frontend is just styling" or "backend is easy" are both wrong answers.
Take-home (4 to 6 hours). A complete feature with auth, schema, API, UI, and tests. This is the gold-standard assessment for full-stack.
Architecture chat. "Walk me through a previous full-stack project — what worked, what would you change?"
A strong full-stack candidate scores 3/5 on frontend, 3/5 on backend, and 4/5 on communication. If they are 4/5 frontend and 2/5 backend, they are a frontend dev who deploys their own code, not a full-stack engineer.
Framework specialists: React, Node.js, PHP
Specialists are worth the premium when:
- The stack is committed. Your codebase is 10K plus lines of React. A specialist drops onboarding from four weeks to one.
- Depth is the bottleneck. Complex state management, performance optimization, advanced patterns.
- Senior-level mentorship is needed. A senior React specialist can set patterns and mentor mid-level devs at the same time.
React specialist
What they bring: deep React (hooks, context, suspense, concurrent features), strong component architecture, state management mastery (Redux, Zustand, Jotai, MobX), TypeScript with React, and testing.
2026 salary range:
- Junior (0–2): $60K–$85K
- Mid (2–5): $90K–$155K
- Senior (5+): $155K–$190K
Red flags: only knows class components. Cannot explain why state management matters. Portfolio is all CRUD with no complex state or perf work.
Good signal: can talk about code splitting, lazy loading, memoization. Knows when to test behavior vs implementation. Has built something hard — real-time, complex forms, animation work.
Node.js specialist
What they bring: deep Node (async/await, streams, worker threads, the event loop), production framework experience (Express, Fastify, NestJS), database integration through ORMs like Prisma or TypeORM, and API design instincts.
2026 salary range:
- Junior (0–2): $55K–$85K
- Mid (2–5): $85K–$150K
- Senior (5+): $150K–$200K+
Red flags: only knows frontend JS. Cannot explain the event loop or async patterns. Portfolio has no production backend work.
Good signal: can discuss N+1 queries, Redis caching, when to scale horizontally vs vertically. Has built integrations and run them in production.
I built the Cuez API rewrite in Node-adjacent territory and dropped response time from 3 seconds to 300 milliseconds (a 10x improvement) while cutting infrastructure costs by about 40 percent. That is the kind of work a Node specialist should be able to walk through. Read Cuez: API optimization from 3s to 300ms.
PHP developer
What they bring: PHP language depth, modern frameworks (Laravel, Symfony), MySQL fluency, and often WordPress experience (themes, plugins, WooCommerce).
2026 salary range:
- Junior (0–2): $35K–$50K
- Mid (2–5): $60K–$100K
- Senior (5+): $120K–$170K
PHP pay trails Node and Python by roughly 20 to 30 percent because the market reads PHP as legacy. That is a perception problem, not a technology problem — Laravel is one of the better-designed frameworks I have used and PHP still powers a large share of the public web.
Red flags: only procedural PHP, no modern framework experience. No testing. WordPress-only without broader exposure.
Good signal: real Laravel or Symfony experience. Strong API design. Testing as part of normal work.
I shipped the GigEasy MVP in three weeks for a Barclays/Bain-backed fintech using Laravel, React, and AWS. PHP is alive and well when the engineer is good. See GigEasy: shipping a fintech MVP in three weeks.
Interview questions by role
Mix technical and behavioral. Watch the reasoning, not just the answer.
Frontend questions
State management. "You are building a complex dashboard with filters, real-time updates, and undo/redo. How do you manage state? What trade-offs?" Red flag: jumps straight to Redux without considering alternatives.
Performance. "A React app is slow — three-second page loads. Walk me through the diagnosis." I want to hear about Chrome DevTools, bundle size, code splitting, lazy loading.
Component design. "Design a reusable date picker that has to work in 10 different projects." API design thinking. Documentation. Testing strategy. Balance of flexibility and simplicity.
API integration. "Your API returns data in a shape you did not expect. How do you handle it?" Listen for validation, transforms, error boundaries, fallbacks.
Accessibility. "Why does it matter? What WCAG-compliant work have you done?" If they say "nice to have," that is the answer.
Backend questions
System design. "Design a URL shortener that handles a million requests a day. Database? Endpoints? Scaling?"
Database optimization. "An endpoint that lists posts takes five seconds. Why? Fix?" I want N+1, indexing, query optimization in the answer.
API design. "Design a REST API for a payment system. Endpoints? Errors? Idempotency?" Idempotency for payments is the load-bearing answer.
Reliability. "A critical service fails. How do you design for prevention and minimize downtime?" Redundancy, monitoring, incident response.
Trade-offs. "SQL or NoSQL for user data? Microservices or monolith? Why?" There is no single right answer. The wrong answer is dogmatism.
Full-stack questions
End-to-end design. "Build a save-to-favorites feature. Walk me through schema, API, UI, error handling."
Trade-offs. "Your app is slow. Optimize frontend or backend? How do you decide?" The right answer involves measuring before deciding.
Cross-stack debugging. "Works locally, breaks in production. How do you debug?" Logs, environment differences, dependency checks.
Learning curve. "We are switching from React to Vue next quarter. How do you approach it?" Growth mindset is the signal.
Communication. "You built a feature the PM did not expect. They want it changed. What do you do?" Listen for ownership and adaptation, not blame.
Project type to recommended role
Match your project shape to the right hire. Most projects need a mix.
| Project type | Recommended role | Why | Example |
|---|---|---|---|
| MVP / startup | Full stack | Speed beats specialization | New SaaS with 10 core features in 3 months |
| Complex frontend / UI-heavy | Frontend specialist | State, perf, animations, a11y | Dashboard with real-time charts and collaborative editing |
| API / scalable backend | Backend specialist | Database, caching, microservices | Payment processing, real-time notifications, data pipelines |
| Real-time / chat app | Frontend + backend pair | Heavy on both sides | Slack-style tool, collaborative editor, live notifications |
| Mobile-first | Frontend specialist | Responsive, touch UX, mobile perf | Web app with 80%+ mobile traffic |
| Data-heavy / analytics | Backend specialist | Schema, pipelines, query work | Reporting platform, warehouse, dashboards |
| WordPress / CMS | PHP developer | Theming, plugins, e-commerce | Content site, WooCommerce store |
| React + Node codebase | React specialist + Node specialist (or two full-stack) | Stack benefits from depth | Mature SaaS at 50K+ lines |
| Monolithic CRUD app | Full stack | One person can own the loop | Inventory tool, task list, internal dashboard |
| Microservices / distributed | Senior backend specialist(s) | Complexity demands seniority | Platform with 100+ third-party integrations |
Specialist vs generalist: when to hire each
This is the most important call you will make in the first 10 hires. Get it wrong and you lose months.
Hire a generalist when
- Your team is under five engineers.
- You are still building the MVP.
- Your stack is not proven and might pivot.
- The product is genuinely simple — CRUD, blog, small dashboard.
- You are pre-revenue or under $500K ARR. A $150K specialist is too heavy.
The trade-off: slower delivery on complex features, but faster iteration overall and lower base cost.
Hire a specialist when
- Your stack is committed — 50K plus lines of one framework.
- Your codebase has real complexity (real-time, microservices, heavy algorithms).
- Performance is a feature, not a bug fix.
- The team is past about eight engineers.
- You are scaling past $2M ARR.
The trade-off: higher salary and longer onboarding, but faster delivery on complex work and free mentorship for the rest of the team.
Hybrid model (most scaling teams)
- 2 to 3 full-stack devs as the velocity backbone
- 1 frontend specialist if the UI is non-trivial
- 1 backend specialist if scale or integrations are non-trivial
- 1 specialist for every 3 full-stack as you cross five total engineers
A 10-person engineering team I would design today: 6 full-stack, 2 frontend specialists, 2 backend specialists, plus a DevOps engineer. That gives you breadth, depth, and an on-call rotation that does not eat the same person every week.
Common hiring mistakes by role
These are the mistakes I have either made or watched a client make.
1. Confusing seniority with role fit
A senior backend engineer hired into a UI-heavy project is bored in three months and gone in six. Match seniority to project complexity, not to salary budget. Ask candidates to walk through their last three projects. If a "senior full-stack" person has done only frontend, they are not actually full-stack.
2. Hiring a generalist when you need a specialist
You have 50K lines of React. You hire someone who is 60 percent frontend, 40 percent backend. They struggle with advanced patterns. The codebase rots a little every sprint. Use the matrix above. Test specifically for the depth you need.
3. No technical assessment
Personality is not a substitute for code. Always include a coding challenge or a take-home. It is the single best predictor of on-the-job performance. The best teams I have worked on all do this. The worst do not.
4. Underestimating backend complexity
Hiring a mid-level full-stack to build your first real API. They design something that breaks at 1,000 users. You hire a senior to redesign it. Now you have spent twice. Ask system design questions. Listen for scaling, indexing, caching, load balancing.
5. Ignoring communication
A brilliant coder who cannot explain decisions and writes code nobody else understands is a bottleneck dressed as an asset. Score communication as heavily as technical skills. Ask about disagreements. The right answer involves talking, not rewriting in silence.
6. Hiring too junior for your stage
A 10-person startup with a complex product hires three juniors and one mid-level. There is not enough senior guidance. Juniors slow each other down. Code quality drops. Rule of thumb: for every two juniors, one mid-level or senior to guide them.
7. Overweighting framework experience
You post a Vue role and screen out a brilliant React engineer who could learn Vue in two weeks. You hire a junior Vue dev instead and they struggle. Prioritize fundamentals. Strong engineers learn frameworks fast.
8. Hiring remote without async skills
A smart developer who needs constant synchronous communication on a distributed team is blocked all day. Ask explicitly about async habits. Documentation. Async video updates. Working independently.
FAQ
Should I hire a freelancer or a full-time employee?
Freelancer for bounded projects, MVPs, or temporary capacity — flexible and easy to end, but more expensive per hour and lighter commitment. Full-time for core roles, mentorship, and long-term product depth — lower total cost, more commitment. I usually recommend full-time for backend leadership and freelance for specific overflow or specialist work.
How much does it cost to hire and onboard a developer?
Recruiting runs $3K to $10K (agency or your time). Onboarding is two to eight weeks before they are at full output. Total first-year cost on a $100K engineer is closer to $120K to $140K once you include recruiting overhead, equipment, and ramp.
What is the difference between a React developer and a frontend developer?
A frontend developer knows HTML, CSS, JS, and at least one framework. A React developer has deep React expertise — advanced state management, performance, testing patterns. Hire a React specialist when your codebase is committed to React and you need someone productive in week one.
Can a full-stack developer replace two specialists?
Roughly 70 to 80 percent of the time, yes — at MVP scale. Once your product needs deep specialist work (distributed systems, complex frontend), specialists go further. A $120K full-stack beats $300K of specialists when the work does not require depth. It does not beat them when it does.
How do I know if I need a backend specialist?
You need one if you handle 1,000+ requests per second, manage 100 GB plus of data, run microservices, handle PII or payments, or require 99.9 percent uptime. You probably do not need one if your product is CRUD, has under 100 users, or runs on a battle-tested stack with a senior already in place.
Where to source candidates by role
Not every channel works for every role. A short, opinionated map.
Frontend developers. Strong public portfolios live on GitHub, CodePen, and personal sites. Filter for engineers who maintain a side project longer than six months — the discipline shows. LinkedIn searches for "React" or "Vue" plus your city or "remote" still work surprisingly well. Frontend conferences (React Summit, VueConf, JSConf) have job boards worth scanning.
Backend developers. GitHub matters more here than portfolios. Look at the issues they file and the PRs they review on open-source projects. A backend engineer who consistently writes thoughtful PR comments is almost always a better hire than one with a polished resume and no public footprint. Hacker News "Who is Hiring" threads and Lobsters job posts pull a higher caliber than generic boards.
Full-stack developers. Y Combinator's Work at a Startup, AngelList Talent, and indie communities (Indie Hackers) skew full-stack. Founders who have shipped a side product almost always have full-stack chops, even if their LinkedIn says otherwise.
Framework specialists. Topical communities — Reactiflux for React, Discord servers for individual frameworks, the Laravel community on Twitter — are where the people who care about depth hang out. Specialist agencies and platforms (Toptal, Gun.io for vetted seniors) are also worth the markup if your timeline is tight.
Remote-first hires. Remote OK, We Work Remotely, and Working Nomads are the obvious boards. The less obvious move is to post on a smaller, role-specific job board and pay for placement. Smaller boards filter out the volume of unqualified applicants larger boards generate.
I have hired off all of these channels at different companies. The strongest signal in any channel is the same: engineers whose public work shows judgment, not just output.
What to put in the job description
Most job descriptions are bad in the same way. They list 12 required skills, 8 nice-to-haves, and three paragraphs about company culture before mentioning what the job actually is. The good ones cut to the work.
A pattern I would steal:
Title. Specific. "Senior Full-Stack Engineer (React + Node)" beats "Software Engineer." Specificity filters before you read a single resume.
The first paragraph is the work. What will this person ship in their first 90 days? Real examples. Not "drive product velocity" but "rebuild our checkout flow with Stripe Elements and ship it to production by end of Q2."
Required skills, capped at five. Anything past five is a wishlist, not a requirement. Be honest about which are non-negotiable.
Stack, dependencies, and team shape. What do they work with? Who do they pair with? How many engineers, what is the on-call rotation, what is the deploy cadence?
Compensation range. Real numbers. Posting "competitive" instead of a range cuts your applicant pool by 40 to 60 percent according to most recent recruiting research. Salary transparency is also law in a growing list of US states; check before you skip the range.
Application instructions. A take-home is fine. A take-home plus four interview rounds plus a culture deck plus a behavioral assessment is not. Respect their time and you will get better candidates.
One concrete signal of culture. Not values bullet points. One paragraph about how decisions actually get made.
A senior engineer reading a JD can usually tell within two minutes whether you have ever worked with a senior engineer. Make it obvious you have.
Compensation and equity by role
Base salary is only one part of the package. The full picture, by role:
Frontend. Less equity-heavy than backend (slightly less perceived risk in the market). Typical breakdown for a senior US frontend role: $150K base, 0.05 to 0.25 percent equity at Series A, $10K to $20K signing bonus.
Backend. Equity slightly higher because the perceived complexity of the work is higher. Senior US backend at Series A: $160K to $200K base, 0.1 to 0.5 percent equity, $15K to $30K signing.
Full-stack. Sits between the two. The discount on base salary reflects the breadth-over-depth trade-off; the discount on equity is smaller because full-stack engineers are often the most leverageable hires at early-stage. Senior US full-stack: $145K to $185K base, 0.1 to 0.4 percent equity.
Specialists (React, Node, PHP). The 15 to 25 percent base premium is real. Equity is roughly equal to a generalist of the same seniority. The premium is the cost of avoiding ramp time on a stack you have already committed to.
Beyond base and equity:
Remote work. Becoming the default for senior roles. Expect to lose candidates if you require five days in office.
Learning budget. $2K to $5K a year for books, courses, conferences. Cheap for the company, valuable to engineers who care about staying current.
Equipment. Laptop, monitor, chair, sometimes a stipend for home-office setup. Not negotiable for senior remote hires.
Time off. Unlimited PTO sounds generous and often results in less time taken than a defined 25-day policy. Define a minimum if you go unlimited.
Health and retirement. US-standard. Pay attention to mental health coverage; it shows up in retention numbers.
The compensation conversation is the moment in the interview process where most CTOs lose senior candidates. Be direct. Share the range early. Negotiate honestly. The candidates worth hiring expect that, and walking through a six-week interview process to discover an unworkable comp at the end is the fastest way to burn your reputation in the talent network.
The first 90 days: setting up a new hire to succeed
Most hiring failures are onboarding failures in disguise. A strong candidate joins a team without context, without a clear first project, and without an explicit feedback loop, then quietly drifts for two months while everyone assumes someone else has them sorted out. By month three the relationship is awkward. By month six they are looking again.
A 90-day plan I have used and seen used to good effect:
Days 1 to 7. The new hire gets a written welcome doc with the codebase tour, the deploy pipeline, the team's communication norms (where decisions live, what Slack channels matter, how PRs get reviewed), and a list of three to five short-term outcomes for the first month. Their manager runs a 1:1 on day 1, day 3, and day 7. The goal of week one is "no surprises" — they know what good looks like.
Days 8 to 30. The first real PR ships within two weeks. Small, low-risk, ideally tied to a real customer-visible improvement so they get the hit of seeing their code in production. Pair programming on at least two reviews. By the end of month one they should have run a deploy themselves, attended every recurring meeting, and met every cross-functional partner they will work with regularly.
Days 31 to 60. First medium-scoped feature. They write the design doc before code. The doc is reviewed by the team, not just the manager. They lead the implementation and ship it. Manager runs a structured 30-day review covering "what surprised you, what is missing, what should we change?" Listening matters more than talking in this conversation.
Days 61 to 90. First independent ownership. They own a feature, a system area, or a small project end to end. Decisions are theirs. The manager is available but does not run the show. By day 90 they should be giving feedback on the team's process, not just receiving it.
The cost of bad onboarding is not just the salary you pay during the slow ramp. It is the trust the new engineer loses in the team's competence, which is much harder to rebuild than to establish in week one.
When you do not need to hire at all
Sometimes the answer is not "hire faster." Sometimes it is "do not hire yet."
Three alternatives I would consider before posting a role:
Fractional senior or fractional CTO. A senior engineer working 10 to 20 hours a week, focused on architecture and mentorship. The math is gentler than full-time, the commitment is lighter on both sides, and the conversion to full-time later (when the company is bigger and the role is clearer) is a clean handoff. The fractional CTO service page lays out how I structure that work. This is often the right move for pre-Series A teams that have not hired a senior before.
Project-based engagement with a senior solo or small studio. Bounded scope, fixed budget, defined deliverable. You skip the recruiting cycle, the equity negotiation, the year-one retention risk. You get a senior shipping the work without taking on the long tail of full-time employment.
Internal promotion plus mentorship. Sometimes the right senior is already on your team, one promotion away. Pair them with a fractional senior or external advisor for six months and you build internal capability instead of buying it. Slower than a hire, but the loyalty payoff is real.
The default answer in our industry has become "post a role and hire for it." That is sometimes correct. It is not always correct. The right question is "what is the smallest investment that fixes the actual problem?" — and the answer is often something cheaper and faster than a full-time hire.
Reflecting on the hires that actually paid off
The hires that paid off in my career — both as a hiring manager and as the senior brought in to fix things — had three things in common.
The first was honesty about the role. The job description matched the actual job. Nobody was being hired as "a full-stack developer who will mostly do DevOps." The second was a real assessment, not a vibes interview. Code, code review, system design, written communication. The third, and probably the most important, was explicit context for the first 90 days. What does success look like? What does failure look like? Who do you ask when you are stuck?
If any of those three is missing, the hire usually fails for reasons that have nothing to do with the candidate. That is the part I wish someone had told me at 25.
If you want a hand mapping your team needs, scoping the first three roles, or reviewing a job description before you post it, get a quote in 60s. I have been the senior cleanup engineer on more rebuilds than I would like to admit.
Related reading
Services I offer
- Custom web applications: solo senior alternative to hiring a team
- Fractional CTO: technical leadership for your first 2–3 hires
Case studies
- GigEasy MVP in 3 weeks: what a senior solo can ship for a Barclays/Bain-backed fintech
- bolttech payment orchestration: 40+ payment providers at a $1B+ unicorn
- Cuez API 10x faster: 3s to 300ms
Related guides