Jonathan runs a logistics company in El Segundo. He’d been quoted $38,000, $112,000, and $340,000 for what he described as “the same project” to three different firms. By the time he called us, he was convinced someone was lying. The truth was uglier. Nobody was lying. Jonathan just didn’t have a scope yet, so each firm was quoting a different imaginary project.
Cost estimation for software development breaks down the same way for almost every non-technical founder. You describe the idea. You get back a range so wide it’s useless. You assume the high quotes are padding and the low quotes are honest, when often the opposite is true. Then you sign with the cheapest option and get an invoice six months later that somehow matches the most expensive quote.
This guide is the framework we walk founders through before they talk to any vendor. Follow it in order and you’ll walk into vendor calls with your own number already in hand. That’s the only way to tell if a quote is fair.
Why Software Estimates Vary So Wildly
Before we get into the framework, it helps to understand why the same project can cost $40k from one team and $400k from another. It’s usually not the code that differs. It’s what’s included around the code.
The Standish Group CHAOS report tracks software project outcomes year after year. Its most consistent finding is that the majority of projects overrun on budget, time, or scope, and the biggest driver is unclear requirements at kickoff. McKinsey’s research on large IT projects found that the average large software project runs 45% over budget and delivers 56% less value than predicted.
Translation: most quotes are wrong because most scopes are wrong. If you want a real estimate, you need to define the scope yourself first. Vendors can help, but the founder who shows up with a defined scope gets better quotes than the one who shows up with an idea.
Step 1: Size the Scope Before You Size the Cost
Every estimate starts with the same question: how big is the thing you’re actually building? Most founders underestimate this by a factor of two to three.
A useful shorthand: count the number of distinct screens, user roles, and integrations. That gives you a rough sizing bucket. If you’re building a first version specifically, our guide on MVP development cost covers the leaner end of this spectrum.
| Size bucket | Screens | User roles | Integrations | Typical hours |
|---|---|---|---|---|
| Small | 5–12 | 1–2 | 0–2 | 400–800 |
| Medium | 12–30 | 2–3 | 2–5 | 800–2,000 |
| Large | 30–80 | 3–5 | 5–10 | 2,000–5,000 |
| Enterprise | 80+ | 5+ | 10+ | 5,000+ |
These hour ranges include design, frontend, backend, QA, project management, and deployment setup. Writing code is usually only 40–60% of the total hours. Design, testing, reviews, and project coordination account for the rest. Founders who forget that end up with a quote that only covers the code and then get surprised by line items later.
One more thing about scope: features are not what determines cost. Flows determine cost. “User login” is one feature but three flows (sign up, sign in, password reset). Each flow takes 8–30 hours to build depending on edge cases. Count flows, not features, if you want a more accurate estimate.
Step 2: Pick Your Team Composition and Rate Tier
Who builds the software matters as much as what they build. The same 800-hour project can come in at $56,000 or $200,000 depending on who’s writing the code.
Here’s what US-based talent actually costs in 2026, based on BLS wage data for software developers plus agency overhead.
| Team type | Blended hourly rate | Quality | When to use |
|---|---|---|---|
| Offshore freelancer / agency | $25–$60 | Mixed, communication risk | Simple internal tools, no critical data |
| US-based freelancer | $80–$150 | Depends on individual | Small well-scoped projects |
| Small US studio | $125–$200 | Consistent, senior-led | Most MVPs and custom builds |
| Mid-size US agency | $175–$275 | Process-heavy, PM overhead | Regulated industries, large scopes |
| Enterprise consulting firm | $275–$450 | Strong on paper, thin on code | Rarely correct for private companies |
A blended rate means the average across the team, not the rate of one person. A senior engineer at $225/hour plus a junior at $95/hour plus a designer at $140/hour averages out to the blended number you’ll see in a proposal.
If you want to understand what separates a good studio from a bad one, we broke it down in how to choose a software development company. The short version: the number that matters is not the hourly rate but the hours per feature. A $200/hour team that delivers a feature in 20 hours is cheaper than a $80/hour team that takes 80 hours and still has bugs.
Step 3: Apply Complexity Multipliers
Scope and team rates get you a baseline. Complexity multipliers tell you how much to adjust that baseline for the specific features in your project. Each of these adds cost on top of the base estimate.
| Complexity driver | Cost multiplier | Example |
|---|---|---|
| Real-time features (chat, live updates) | +15–40% | Live order tracking, collaborative editing |
| Multi-tenancy (SaaS with many customers) | +25–50% | B2B platforms, isolated customer data |
| Complex permissions (role-based access) | +20–35% | Managers see X, reps see Y, admins see all |
| Payments with subscriptions | +10–20% | Stripe subscriptions, proration, failed-payment recovery |
| Compliance (HIPAA, SOC 2, PCI) | +30–60% | Healthtech, fintech, data-sensitive apps |
| Native mobile (iOS + Android) | +40–80% | Separate codebases vs. responsive web |
| AI/ML features (beyond API calls) | +20–50% | Custom model training, not just OpenAI wrapping |
| Legacy system integration | +20–40% | Connecting to old ERPs, unusual databases |
These multipliers stack. A SaaS healthtech product with real-time features and native mobile would layer +25% (multi-tenancy) + +20% (real-time) + +40% (HIPAA) + +50% (native mobile) on top of the base. That’s why a “simple CRM” quote of $80,000 becomes a “HIPAA-compliant multi-tenant real-time care-coordination platform” quote of $280,000. Same product category, different complexity profile. For a deeper look at how these factors play out specifically in app development cost, we break it down by platform and feature set.
Step 4: Add the Hidden Costs Nobody Warns You About
This is where most budgets blow up. The build quote is rarely the full cost of launching and running software. Here’s what gets billed separately by most teams and what you should plan for.
Hosting and infrastructure
Your software needs somewhere to run. Annual cost depends on stack and traffic.
- Static frontend on Cloudflare or Vercel: $0–$240/year
- Small backend with one database: $600–$3,600/year
- Production backend with queues, caching, and monitoring: $3,600–$18,000/year
- HIPAA-eligible infrastructure (AWS HIPAA, GCP HIPAA): +40% on top of the above
Third-party services
Almost every modern application uses external APIs. Budget for them before launch.
- Email delivery (SendGrid, Postmark): $240–$1,200/year
- SMS (Twilio): $0.0075–$0.04 per message, often $1,200–$6,000/year at modest volume
- Auth (Auth0, Clerk): $0–$4,200/year up to 10,000 users
- Payments (Stripe): 2.9% + $0.30/transaction, not a fixed cost
- Analytics, monitoring, error tracking: $1,200–$6,000/year combined
- Maps, geocoding, weather, AI APIs: highly variable, model each one
Legal and compliance
Privacy policy and terms of service from a real lawyer: $1,500–$5,000. A DPA if you process EU data: $1,000–$3,000 more. SOC 2 readiness if you’re selling to enterprise: $15,000–$50,000 for the first audit, plus ongoing tooling.
App Store and platform fees
Apple Developer Program: $99/year. Google Play: $25 one-time. Stripe/Paddle: transaction fees on revenue, not a line item but it shows up in your P&L.
Post-launch bug fixes and iteration
Software is not done at launch. Plan for 6–10% of the build cost in the first three months for bug fixes and small changes nobody predicted. If your build was $120,000, expect to spend another $7,000–$12,000 in the three months after launch.
Ongoing development
If the product works, you’ll want to keep building. Light iteration runs $4,000–$12,000/month. Active development with a dedicated team runs $15,000–$50,000/month. This is part of your operating budget, not your launch budget, but leave it out of your model at your peril.
Step 5: Build In a Contingency Buffer
Scope grows. Always. Not because people are sloppy, but because you learn things during the build that you couldn’t have known during scoping. A well-run project absorbs those discoveries within the timeline. A poorly scoped one doesn’t.
The standard contingency for custom software is 20%. We recommend 25% for first-time founders, 30% for anything involving compliance, and 40% if the scope document is less than five pages. Yes, that sounds high. It is also accurate.
Concretely: if your calculated build cost is $100,000, budget $125,000. If the project comes in at $105,000, you have $20,000 of cushion for hosting and marketing. If it comes in at $128,000, you’re not panicking and you’re not calling your investor for a bridge round.
The Cost Calculator: Small, Medium, Large
Here’s what the framework looks like applied to three project sizes. These are 2026 US studio rates, blended hourly around $175.
Small project (internal tool or simple consumer app)
| Line item | Estimate |
|---|---|
| Build (600 hours × $175 blended) | $105,000 |
| Design (included above) | (bundled) |
| Hosting (year 1) | $1,800 |
| Third-party services (year 1) | $2,400 |
| Legal | $2,500 |
| Contingency (20%) | $21,000 |
| Post-launch iteration (3 months) | $7,000 |
| Total year 1 | $139,700 |
Medium project (B2B SaaS single-tenant, no compliance)
| Line item | Estimate |
|---|---|
| Build (1,400 hours × $175 blended) | $245,000 |
| Complexity uplift (payments + permissions, +25%) | $61,250 |
| Hosting (year 1) | $4,800 |
| Third-party services (year 1) | $6,000 |
| Legal | $4,500 |
| Contingency (25%) | $76,562 |
| Post-launch iteration (3 months) | $18,000 |
| Total year 1 | $416,112 |
Large project (multi-tenant SaaS with HIPAA or SOC 2)
| Line item | Estimate |
|---|---|
| Build (3,200 hours × $200 blended) | $640,000 |
| Complexity uplift (multi-tenancy + compliance + real-time, +90%) | $576,000 |
| Hosting (year 1, HIPAA-eligible) | $14,400 |
| Third-party services (year 1) | $12,000 |
| Legal + SOC 2 readiness | $35,000 |
| Contingency (30%) | $394,920 |
| Post-launch iteration (3 months) | $45,000 |
| Total year 1 | $1,717,320 |
A few things to notice. The contingency and complexity uplifts grow faster than the raw hours. The hidden costs (hosting, legal, services, iteration) add 15–20% on top of the build quote even before contingency. And a project in the “large” bucket is not 5x a “small” project, it’s 12x once you stack everything.
If you’re staring at these numbers wondering whether to build or buy, that’s a separate analysis worth running before you commit. We cover the full cost breakdown for custom software development in a companion guide.
A Worked Example With Real Numbers
Let’s run Jonathan’s logistics project through the framework. He wanted a dispatch platform with driver mobile app, customer portal, and integrations with his existing accounting system.
Step 1. Scope sizing. We counted 28 screens across three user types (dispatchers, drivers, customers), plus 4 integrations (accounting system, maps, SMS, email). That’s a medium-to-large project, around 1,800 hours of work.
Step 2. Team rate. He wanted a US studio for accountability, not offshore. Blended rate: $185/hour. Base build: 1,800 × $185 = $333,000.
Step 3. Complexity multipliers. Multi-role permissions (+25%), native mobile for drivers (+50%), real-time dispatch updates (+25%). Combined uplift: +100% on the portions that hit each driver. Net uplift on the total: roughly +45%, or $150,000.
Step 4. Hidden costs. Hosting (HIPAA not required, but high-volume): $6,000/year. Third-party (Twilio SMS for drivers, maps API, payments): $9,000/year. Legal: $3,500. Post-launch iteration for three months: $24,000.
Step 5. Contingency. 25% of $483,000 build = $120,750.
Total year 1 budget: $696,250.
The $38,000 quote he got was a freelancer who planned to build only the dispatcher screens, no mobile, no integrations. The $112,000 quote was a small team that would deliver working software but cut corners on the mobile experience and skip the integrations. The $340,000 quote was actually the closest to reality, but still missed hosting, services, and contingency. None of the three vendors quoted the real project because Jonathan hadn’t described the real project yet.
He ended up going with the $340,000 vendor after we helped him scope it properly. Final delivered cost eight months later: $412,000. Inside contingency. Shipped on time.
Red Flags in Vendor Estimates
Once you have your own number, you can spot estimates that are wrong before you commit. Here’s what to watch for.
- A quote that comes in 40%+ below your own calculation. Either the vendor is cutting something you’d want, or they’ll bill you for it later. Ask them to walk you through their hours and rate. If they can’t, walk away.
- A fixed price with no detailed scope document. Fixed price is great when the scope is detailed. Fixed price on a vague scope is how founders end up with software that technically meets the contract but doesn’t solve the problem.
- No line items for QA, deployment, documentation, or handoff. These always exist. If they’re not in the quote, they’ll be in a change order.
- No contingency discussion. Vendors who don’t mention contingency either include a hidden padding or have no plan for scope changes. Neither is good.
- Timeline that’s more than 20% faster than typical. Software doesn’t speed up because you pay more. Aggressive timelines fail more often than not, per every IT project study of the last 30 years.
What We Charge at LCGC
Full transparency because the team at LCGC gets asked this constantly. Our blended rate on a typical engagement is $175–$210/hour depending on team mix. We scope every project in phases with fixed prices per phase, usually $25,000–$80,000 per phase for MVPs and $60,000–$180,000 per phase for larger builds. We build in 20–25% contingency up front and tell clients when we’re going to use it, not after.
We don’t do open-ended retainers on undefined scope. Understanding software development pricing models helps here: if you don’t know what you want built, the first engagement is a scoping phase ($8,000–$15,000) that produces a real spec you can shop around, not just to us. Yes, that means clients sometimes take our spec to a cheaper vendor. That’s fine. The spec still produces better software than no spec.
Full details on the approach live under custom software development services and MVP development for pre-revenue builds. Both pages list what’s included in scoping versus build phases.
Making the Call
Here are three practical takeaways that will save you more money than any negotiating tactic.
- Do your own estimate before any vendor call. Even a bad estimate beats showing up with no number. Vendors calibrate their quotes to the information you give them.
- The build quote is half the picture. Hosting, services, legal, contingency, and post-launch iteration add 30–50% on top. Model the full year-one cost, not just the invoice for the build.
- Scope discipline is the cheapest lever you have. Cutting features you don’t need saves far more than negotiating rates. A tighter scope also lowers risk.
If you want a second opinion on your estimate before you sign with anyone, we’ll take a look for free. Bring your feature list, any quotes you’ve received, and whatever you know about timelines. We’ll tell you honestly where the estimate is realistic, where it’s padded, and where it’s quietly missing something that will cost you later. Schedule a free 30-minute consultation and come with your rough numbers. We’ll sharpen them.