The fully-loaded annual cost of a salaried developer, the crossover expressed in hours per week, the EPF and ESI headcount thresholds that make the identical hire cost two companies two different amounts — and the point at which we would tell you to stop paying us.
Hire in-house once you can honestly forecast more than about 900 hours of development work a year — roughly 18 hours a week, every week, for twelve months. Below that, an agency is cheaper. A developer on a ₹8,00,000 CTC costs about ₹10,50,000 a year once hardware, tooling, recruitment and statutory contributions are counted, and returns roughly 215 productive working days. The same ₹10,50,000 buys about 875 hours — around 110 days — from a small Indian agency at ₹1,200 an hour. So the crossover is not the hourly rate, and it never was. It is your utilisation: not who is cheaper per hour, but whether you have enough work to keep one person busy all year. Most companies who ask us this question do not.
We are a development agency. We are paid when you choose the agency column, so read the rest of this with the suspicion that deserves — and then note that the rule above sends any company with a real product roadmap in-house by year two, and that the section titled “when you should fire us” is not decorative. Every ₹ figure in the ZoopCoder column is our own published price from our pricing page, not a competitor’s estimate of us.
Almost every version of this comparison online compares a salary to an hourly rate, which is not a comparison at all. A salary is not what an employee costs. Here is the same hire with everything in it, at a ₹8,00,000 CTC — a realistic 2026 offer for a developer with three to five years of experience at a small Indian company.
| Line item | Lean (remote, referred, under 10 staff) | Typical (office, consultancy hire, 20+ staff) | Note |
|---|---|---|---|
| CTC offered | ₹8,00,000 | ₹8,00,000 | The only number most founders budget |
| Employer EPF (12% of basic, ceiling ₹15,000/mo) | ₹0 | ₹21,600 | Triggered at 20 employees, not at this hire |
| Gratuity accrual (≈4.81% of basic) | ₹0 | ₹19,240 | Triggered at 10 employees; vests after 5 years |
| Recruitment fee | ₹0 | ₹66,000 | Consultancies typically quote 8–8.33% of annual CTC |
| Laptop + peripherals (amortised over 3 years) | ₹25,000 | ₹40,000 | ₹75,000–₹1,20,000 up front |
| Software, cloud and AI tool seats | ₹20,000 | ₹60,000 | Repos, CI, design tools, staging infrastructure, coding assistants |
| Desk / workspace | ₹0 | ₹96,000 | ₹8,000/month co-working seat |
| Real annual outlay | ₹8,45,000 | ₹11,02,840 | 106% to 138% of the CTC you budgeted |
| Productive days delivered | ≈215 | ≈215 | 365 − 104 weekend − 10 holidays − 21 leave − sick days |
| Effective cost per productive day | ₹3,930 | ₹5,130 | ₹491–₹641 per hour, if you keep them busy |
Salary and vendor figures reflect what Indian companies and consultancies publicly quote in 2026 and will vary by city and stack. Statutory items are general information, not tax or legal advice — confirm your own position with your CA. Ramp-up is excluded: budget 30–60 days before a new hire is extending your codebase rather than reading it.
Read the last row carefully, because it is the honest case for hiring: a fully-utilised in-house developer costs you ₹491–₹641 an hour, which is below the bottom of the ₹800–₹2,000 band any Indian agency including ours will quote you. Nobody is hiding that. The whole argument is in the two words fully utilised.
This is the table that decides it. The agency column uses ₹1,200 an hour — the midpoint of the ₹800–₹2,000 small-agency band in India, and roughly where our own project work lands. The in-house column uses the lean ₹8,45,000 figure above, which is the most favourable version of the employee case.
| Real work you have | Hours / year | Agency at ₹1,200/hr | In-house (lean) | Cheaper |
|---|---|---|---|---|
| A few changes a month | 120 (2.5 hrs/wk) | ₹1,44,000 | ₹8,45,000 | Agency, by 5.9× |
| A live site plus small features | 300 (6 hrs/wk) | ₹3,60,000 | ₹8,45,000 | Agency, by 2.3× |
| An active product, one release a month | 600 (12 hrs/wk) | ₹7,20,000 | ₹8,45,000 | Agency, but only just |
| The crossover | ~705 (14 hrs/wk) | ₹8,46,000 | ₹8,45,000 | Level |
| A product with a roadmap and a support queue | 900 (18 hrs/wk) | ₹10,80,000 | ₹8,45,000 | In-house, by ₹2.35L |
| A full-time development job | 1,720 (all 215 days) | ₹20,64,000 | ₹8,45,000 | In-house, by 2.4× |
The crossover sits at ~705 hours against the lean employee and ~920 hours against the typical one, which is why the rule above says “about 900 hours” — it is the conservative end, and it is where the decision stops being close.
Every founder we have ever quoted believes they are on the bottom two rows. Almost every one of them is on the top two. Do not estimate the hours — go and count them. Open the last twelve months of your change requests, put an hour figure against each one, and add it up. If you have never had a developer, use the last twelve months of things you wished you could change. The number is nearly always between 300 and 600, and at 300 hours a year an employee is costing you ₹2.3 for every ₹1 of work you actually have.
This is the part of the comparison that Indian cost calculators — including the ones built by Indian agencies — consistently get wrong, because they copy the structure of American articles. In India, the employer-side statutory obligations attached to a developer are triggered by how many people you already employ, not by what you pay this one. The identical hire genuinely costs a five-person company and a twenty-five-person company two different amounts.
| Obligation | Employer cost | Triggered at | Does it hit a ₹8L developer? |
|---|---|---|---|
| EPF (Employees’ Provident Funds Act, 1952) | 12% of basic wages, plus admin charges; mandatory only up to a ₹15,000/month wage ceiling | 20 employees | Yes, once you cross 20 staff — ≈₹21,600/yr at the ceiling |
| ESI (Employees’ State Insurance Act, 1948) | 3.25% of wages, employer share | 10 employees (20 in some states) | No — ESI applies to wages up to ₹21,000/month. But the developer still counts toward the headcount that pulls your other staff in. |
| Gratuity (Payment of Gratuity Act, 1972) | 15 days’ wages per completed year, ≈4.81% of basic accrued | 10 employees | Yes, and it vests after 5 years’ continuous service — a liability that accrues from day one |
| Statutory bonus (Payment of Bonus Act, 1965) | 8.33% minimum | 20 employees | No — the eligibility wage limit is ₹21,000/month. It hits your junior and support staff, not this hire. |
| Maternity benefit (Maternity Benefit Act, 1961) | 26 weeks paid leave, entirely at employer cost; crèche facility at 50+ employees | 10 employees | Yes, and it is uninsurable for above-ESI salaries — a real, rarely-budgeted six-month exposure per eligible employee |
| Payroll TDS (s.192) + quarterly 24Q + Form 16 | No cash cost; a monthly compliance job | First employee | Yes — versus a single 10% s.194J deduction on an agency invoice |
Thresholds and rates as they stand at the time of writing, stated for orientation and not as advice. Voluntary EPF coverage below the threshold is permitted and is common. India’s four Labour Codes redefine “wages” so that basic pay must be at least half of total remuneration — wherever that definition applies to you, both EPF and gratuity rise, because both are computed on basic. Get the current position from your CA before you commit to a salary structure.
The practical consequence is counter-intuitive and worth stating plainly: your first developer is usually your statutorily cheapest one. A four-person company can hire a ₹8,00,000 developer with no EPF, no ESI, no gratuity and no bonus obligation attached. The eleventh employee at that company retroactively brings gratuity, ESI and maternity exposure into the picture for the whole establishment; the twenty-first brings EPF and statutory bonus. If you are hovering at nine or nineteen employees, the true cost of this hire is not their package — it is their package plus the compliance shelf that opens for everyone else. That is a conversation to have with your CA before you make the offer, not after.
Money is the easy half. Most of the regret we see comes from the columns below, and both routes have a failure mode — the honest question is which one your business can survive.
| In-house developer | Small agency (ZoopCoder’s tier) | Freelancer | |
|---|---|---|---|
| Time to start | 6–12 weeks (hiring + notice period) | 3–10 days | 2–7 days |
| Skills you get | One person’s stack | Design + frontend + backend + mobile + QA | One person’s stack |
| Availability for your urgent bug | Immediate — the real advantage | Queued against other clients | Whenever they surface |
| Product knowledge after a year | Deep, and it compounds | Good, but documented rather than lived | Variable |
| How it fails | Resignation — and they hold every credential | Being busy elsewhere in your worst week | Silence. There is no bench. |
| Cost when work goes quiet | Full salary, every month | Zero | Zero |
| GST on what you pay | None (employment is outside GST) | 18%, reclaimable as ITC if registered | Often none (below ₹20L turnover) |
| Tax deduction you operate | s.192 payroll TDS, monthly + 24Q + Form 16 | s.194J, 10% on the invoice | s.194J, 10% on the invoice |
| Who owns the code | You, by default (work made in employment) | Only if the contract assigns it — check | Only if the contract assigns it — check |
| Best for | A live product with a roadmap and a support queue | Building v1, or bursts a solo employee cannot absorb | Small, clear, single-skill work |
| Worst for | Under ~700 hours a year of real work | Day-to-day changes on a mature product | Anything you cannot afford to lose |
One row deserves an asterisk on our side: code written by an employee in the course of employment generally vests with the employer by default, while code written by an agency or a freelancer does not unless the contract says so. If you take nothing else from this page, take that — and get assignment in writing before the first payment, from us or from anyone.
These are the situations where retaining an agency — ours included — is the worse buy, and we would say so on the call:
And the mirror — the cases where hiring is the mistake, stated with the bias declared: an in-house developer cannot design, cannot do DevOps, cannot do QA and cannot do mobile, all at a professional standard, no matter what the CV says. If your next twelve months contain a website, an app and a payment integration, you are not one hire away from that; you are three hires or one team away. That is the situation an agency is genuinely for, and it is the one we are quoting for on our pricing page.
The cheapest correct answer for a company with a live product is usually neither column. It is: an agency builds version one on a fixed price with the repository in your GitHub account and source-code ownership assigned in writing; one in-house developer then takes over day-to-day changes and support at ₹491–₹641 an effective hour; and the agency is retained only for bursts the employee cannot absorb — a payments migration, an app store rewrite, a security review, a redesign. You get the employee’s availability on the small work and the agency’s bench on the big work, and you never pay agency rates for a copy change.
If your total is under the crossover and you do not want to hire at all, the honest middle option is a maintenance plan rather than an open hourly retainer — our own published plans run from ₹3,000 to ₹15,000+ a month, and the arithmetic behind them is in the website maintenance cost guide. Between about 120 and 700 hours a year, a plan plus occasional project work is nearly always cheaper than a salary and always cheaper than an unhappy under-utilised employee.
Hire in-house once you can honestly forecast more than about 900 hours of development work a year — roughly 18 hours a week, every week, for twelve months. Below that an agency is cheaper. A developer on a ₹8,00,000 CTC costs about ₹10,50,000 a year fully loaded and returns roughly 215 productive days; the same ₹10,50,000 buys about 875 hours from a small Indian agency at ₹1,200 an hour. The crossover is not the hourly rate. It is your utilisation.
Budget 25–35% above the CTC you offer. On a ₹8,00,000 CTC the realistic outlay is ₹9,80,000–₹11,20,000: hardware amortised at around ₹30,000, software and cloud seats at ₹20,000–₹60,000, recruitment at ₹0–₹66,000, a desk at ₹0–₹96,000, plus employer statutory contributions where your headcount triggers them. Then subtract capacity: 104 weekend days, ~10 public holidays and ~21 days of leave leave you about 215 working days a year.
Often not. EPF coverage is triggered at 20 employees and ESI and gratuity at 10, counted across the establishment rather than per role, so a five-person company hiring its first developer usually owes none of the three. The same hire at a twelve-person company carries gratuity and ESI, and at twenty it carries EPF too. The statutory cost of a developer in India is a function of your headcount, not their salary. Voluntary coverage below the thresholds is allowed, and the Labour Codes’ redefinition of “wages” raises both EPF and gratuity wherever it applies — confirm the current position with your CA.
Only if you are not GST-registered. If you are registered, you reclaim it in full as input tax credit and the agency’s headline price is its real price. If you are not, it is unrecoverable — and a salary carries no GST at all, because employment is outside the scope of GST. On ₹10,50,000 of agency work that is about ₹1,89,000, which moves the crossover from roughly 875 hours down to roughly 742 — about 15 hours a week instead of 18.
Concentration and notice. One developer holds every deployment credential, every undocumented decision and every half-finished branch, and can resign on 30–90 days’ notice at a time that suits them. An agency carries a bench and a contract — but it also carries other clients, so your urgent Tuesday competes with someone else’s. Choose the failure you can survive: a two-week wait for attention, or a two-month wait for a replacement.
Yes, and for a company with a live product it is usually the cheapest correct answer. An agency builds v1 on a fixed price with the repo in your account and ownership assigned in writing; one employee then runs day-to-day changes; the agency is retained only for bursts — a payments migration, an app store rewrite, a security review. It only works if you own the code and the documentation from day one.
Send us your last twelve months of change requests. We will put an hour figure against each one and tell you which side of the crossover you are on — including when the answer is “hire someone, not us”. If it is us, you get a fixed, itemised quote within 24–48 hours.