Key takeaways
- →Five variables set the price: who supplies the hours, the seniority mix, what you are building, how long the clock runs, and the costs outside the build quote.
- →Engagement model is the biggest multiplier. The same engineer bills $60 to $150 an hour through a vetted marketplace and $120 to $250 inside a US agency.
- →A $140,000 salary is not $67 an hour. Loaded with taxes and benefits it is about $182,000, or roughly $107 for each hour actually spent on your project.
- →One fixed 2,360-hour scope came to $227,200, $255,200 and $436,600 depending only on how it was bought. No feature changed.
- →Budget 15 to 20 percent of the build cost per year for maintenance before you approve the build.
What a software project costs comes down to five variables, and they do not carry equal weight: who supplies the hours, how senior those hours are, what you are asking for, how long the clock runs, and the line items sitting outside the build quote. Buyers tend to worry first about cloud bills, software licenses and which framework the team picks. Those move the number far less than any single one of the five.
In dollars, the consequence looks like this. Further down in this article we price one fixed scope (2,360 hours of work on an internal B2B web app) three different ways, and it lands at $227,200, $255,200 and $436,600. Identical features, same deadline, a $209,400 spread. Nothing about the product changed. Only the five variables did.
Each one is priced here in US terms with the arithmetic shown, so you can read a quote and name what drives it. For the estimating process rather than the drivers, start with how to estimate software development costs. If you already have a number and need it smaller, head to reducing software development costs.
Driver 1: who supplies the hours
Of everything on the list, this is the largest single multiplier. One mid-level engineer doing the same work bills roughly $60 to $150 an hour through a vetted marketplace, and $120 to $250 an hour inside a US development agency. Bring that person in-house and the base salary runs $95,000 to $200,000, depending on seniority and market.
As written, those three numbers are not comparable, and that is where most budgets go wrong. A $140,000 salary is not $67 an hour. Add in payroll taxes, benefits, insurance, equipment and software seats, and the loaded cost comes to around $182,000, or $3,500 a week. Divide that by the hours a full-time employee actually spends on your project in a year (call it 1,700 after vacation, holidays, sick days, internal meetings and the company all-hands) and you pay about $107 an hour. On top of that comes the recruiting fee, commonly 15 to 25 percent of first-year base, plus six to ten weeks of searching before anyone writes a line of code.
On the sticker the agency rate looks worst, and it often is not, since project management, QA, code review and delivery ownership already sit inside it. The marketplace rate looks best and is, as long as you supply the product direction yourself. Before you compare the hourly numbers, compare what each model includes. Our US software developer rates page splits the bands by role.
Driver 2: the seniority mix, not the headcount
Headcount sizes a team, and seniority prices it. A junior developer on a vetted marketplace runs roughly $60 to $80 an hour, a mid-level developer $80 to $115, and a senior $115 to $150. Where specialists are scarce, the top of each band climbs: machine learning, embedded, and anything that touches payments or regulated data price above general web work.
That mix is a real budget lever, and an easy one to model. Picture a four-person build running 20 weeks. Shift one seat from mid at $95 an hour to senior at $135, and the engagement costs $32,000 more. This is the honest cost of the upgrade, a number you can weigh.
The other direction is what you cannot model. A cheaper team stays cheaper only if the work does not come back. Rework is invisible in a quote but shows up on the invoice: a feature built twice costs more than the senior rate would have, and it arrives late. A useful rule is to pay for seniority where decisions are irreversible (architecture, data model, security boundaries) and buy mid-level hours for the volume work on top.
Driver 3: what you are actually asking for
Everyone names scope as a variable, yet almost nobody specifies it. What the brief says is rarely the work. "Reporting" is a static page in one product and a data pipeline with incremental refresh in another, and the two differ by an order of magnitude. Sorting what you want into four complexity classes helps before you price anything.
Class 1, forms and records. Authentication, lists, admin screens, content pages. These are well understood and predictable to estimate, and they are the cheapest hours you will buy.
Class 2, workflow and integrations. Approvals, scheduling, billing, plus anything that syncs with a system you do not control. Every integration brings its own rate limits, sandbox, auth model and outages: scope you inherit rather than scope you choose.
Class 3, data and real time. Live collaboration, offline sync, search at volume, migrations, and anything with a performance budget. Concurrency problems are slow to surface and slower still to fix.
Class 4, regulated or safety critical. Health data, payments, PII at scale, SOC 2 or HIPAA obligations. The code is not harder; the audit trails, access controls, documentation and external review around it are what cost money, and they apply to every feature, not just the sensitive one.
Quotes blow up when classes mix. Put a class 4 obligation over a class 1 feature set and it still prices as class 4. A feature-by-feature breakdown of a typical build is in how much it costs to build an app.
Driver 4: time, including the part that is not work
Nothing bills by the calendar. Work bills by the hour, which means calendar time costs you money only when it converts into hours. That happens in three ways. Two of them are avoidable.
Idle time comes first. At a blended $96 an hour, a five-person team costs $19,200 for a week in which nothing gets decided. Blocked on API credentials, waiting on legal, waiting for one stakeholder to look at a design: the burn rate does not pause. Treat a decision turnaround as seriously as you treat a deadline, and name one person to own it.
Second comes rework from estimating too early. A well-known planning rule of thumb holds that a first estimate at project kickoff can be off by a factor of four in either direction, and the optimism only runs one way: teams pushed to produce a small number produce one, then rebuild toward the real requirement. Discovery is not a delay. It is the cheapest hour on the project, since it is the hour that stops you building the wrong thing.
The third, a hard launch date, is unavoidable and worth paying for. To compress a schedule you add people, and people added late cost more per unit of output than those who started on day one. When the date cannot move, the scope has to, and that is the whole point of the scope, cost and time triangle.
Driver 5: the line items that are never in the build quote
A build quote prices the build. Your budget has to price the product, and the items below routinely arrive after the contract is signed.
- QA and project management, if the engagement model does not include them. A marketplace build has you buy them separately, which explains how a cheap hourly rate and an expensive project can coexist.
- Infrastructure and DevOps setup. Before environments, pipelines, monitoring and backups become a monthly bill, they are one-off engineering work.
- Third-party services. Payments, email, maps, identity, error tracking, AI APIs. Individually small, collectively a line item, and they scale with your usage rather than your budget.
- Security and compliance review. A penetration test or a SOC 2 audit is an external cost that runs on its own calendar.
- Maintenance. Set aside 15 to 20 percent of the build cost each year for dependency upgrades, bug fixes, platform changes and small improvements. For the $227,200 build below, 18 percent comes to $40,896 in year one.
- Your own people. Someone on your side answers questions, reviews designs and tests releases. That work is unbilled. It is not free.
The same product at three prices
Take one fixed scope: an internal B2B web application with authentication, billing, three dashboards and one CRM integration. Assume 1,600 developer hours, 240 design hours, 320 QA hours and 200 project management hours, for 2,360 hours of work held constant across all three options.
| How you buy it | What you pay | Time to delivery | What you take on |
|---|---|---|---|
| Vetted remote team | $227,200 | 20 weeks | Product direction and priorities stay with you |
| In-house, 2 hires plus contracted design, QA and PM | $255,200 | 28 weeks including hiring | Permanent payroll, and a team you keep |
| US agency, blended $185/hour | $436,600 | 20 weeks | Least management on your side, highest rate |
For the remote team, the four role rates apply to the four buckets of hours: 1,600 at $105, 240 at $85, 320 at $65 and 200 at $90. The agency figure is the same 2,360 hours at a blended $185. In-house means two mid-level developers at $140,000 base, loaded to $182,000 each ($3,500 a week apiece) for 20 weeks: $140,000. Add $56,000 in recruiting, at 20 percent of base for two hires, plus $59,200 for the design, QA and management the two developers do not cover. One caveat is worth stating: two salaried people over 20 weeks is 1,600 paid hours, and somewhat fewer project hours once PTO and internal meetings are counted.
Between the cheapest and the most expensive, the spread is $209,400. The in-house column, meanwhile, is not really a project cost at all, because payroll is still running in week 21. That is the real trade. Your choice is between buying a delivery and building a capability.
Price the variables before you price the project
You cannot get a reliable quote for an unreliable brief, and no amount of vendor comparison fixes that. Before you ask anyone for a number, pin down four things: what must ship, what is explicitly out of scope, what is genuinely unknown, and who makes decisions and how fast. Those four turn a guess into a quote you can compare.
Next, price the five variables deliberately instead of inheriting them. Pick the engagement model based on how much direction you can give, not on the hourly rate. Where decisions are hard to reverse, buy seniority. Sort your scope into complexity classes and say which class you are in. Give your own decisions a turnaround time. Add 15 to 20 percent a year for maintenance before you approve the build, not after launch.
Once you are ready to set real rates against real scope, our vetted US network can staff the roles in the worked budget above. Begin with hiring software developers and send the brief, not merely the idea.
Frequently asked questions
What affects software development costs the most?
By a wide margin, the engagement model. Whoever supplies the hours sets the rate before anyone discusses your product: roughly $60 to $150 an hour on a vetted marketplace, $120 to $250 at a US development agency, and $95,000 to $200,000 in base salary for an in-house hire, plus 25 to 40 percent in employer overhead. Scope is a close second, since it sets how many hours you buy. Still, scope is something you control, while the rate is something you choose once.
Why do two quotes for the same project differ by two times?
Usually because they are not quoting the same thing. Before you treat the gap as a discount, check three things. First, what the rate contains: most agency hours include project management, QA and code review, while most marketplace hours bill them separately. Second, the assumed seniority, since a plan built on mid-level hours and one built on senior hours are different products. Third, what each vendor assumed about the unknowns in your brief: the cheaper quote has often priced the optimistic reading of an ambiguous requirement.
Is hiring in-house cheaper than using contractors?
Not for a single project, though often yes for a long-running product. In this article's worked example, two in-house hires came to $255,200 against $227,200 for a contracted remote team, and recruiting meant they took eight extra weeks to start. The in-house column is still costing money in week 21, and that is the actual argument for it: you buy a durable capability and institutional knowledge rather than a delivery. Go in-house when the work is permanent; contract when it has an end.
How much should I budget after launch?
Plan for 15 to 20 percent of the build cost each year. For a $227,200 build, that means $34,000 to $45,000 annually, covering dependency and framework upgrades, security patches, bug fixes, platform changes forced on you by Apple, Google or a payment provider, and small improvements. Hosting and third-party service bills come on top, because they scale with usage rather than with the development budget.
Hire vetted talent