Two proposals landed in Priya’s inbox on the same Tuesday morning. Both were for the same project: a customer portal for her 40-person logistics company in Long Beach. Agency A quoted $145,000 fixed price, deliverable in 14 weeks. Agency B quoted $160–$220 per hour, estimated 800–1,200 hours, with a “flexible scope that evolves with your needs.”
One proposal promised certainty. The other promised flexibility. Neither explained why the pricing model itself would determine whether her project succeeded or failed.
Priya isn’t unusual. Most business owners shopping for custom software development focus on the total number and skip past the pricing structure. That’s like negotiating a salary without asking whether it’s W-2 or 1099. The structure changes everything: who carries the risk, how scope changes are handled, what happens when assumptions turn out wrong, and whether you’ll end up paying for value or for hours.
This guide breaks down every software development pricing model you’ll encounter, explains how software companies charge, and gives you the framework to pick the right one before you sign anything. If you already know your project scope and want a straight answer, book a free 30-minute call and we’ll tell you which model fits.
The Five Software Development Pricing Models
There are five software development cost models in common use. Most agencies default to one or two. Understanding all five means you can push back when a vendor’s preferred model doesn’t match your situation.
Here’s the comparison table first, then the detail.
| Model | You Pay For | Risk Sits With | Best For | Budget Predictability |
|---|---|---|---|---|
| Fixed Price | Defined deliverables | Vendor | Well-scoped projects with clear requirements | High |
| Time & Materials | Hours worked | Client | Evolving products, R&D, exploratory work | Low to medium |
| Dedicated Team | Full-time team allocation | Shared | Long-term product development, 6+ months | Medium |
| Retainer | Reserved monthly capacity | Shared | Ongoing maintenance, iterative improvements | Medium to high |
| Hybrid | Mix of fixed milestones and flexible phases | Shared | Complex projects with some known and some unknown elements | Medium |
Now let’s look at each one honestly.
Fixed Price: You Know What You’re Getting
Fixed-price software project pricing works exactly how it sounds. You define the scope, the vendor quotes a number, and that’s what you pay. If the project takes longer than expected, the vendor absorbs the cost. If you want to add features, that’s a change order with a separate price tag.
How it works in practice
The vendor runs a discovery phase (sometimes free, sometimes $5,000–$20,000) to understand your requirements. They write a scope document that lists every feature, screen, integration, and user flow. Both sides sign off. Development starts against that fixed number.
Milestones break the project into checkpoints. You see working software at each one and approve before the next phase begins. Payment typically follows milestones: 20% upfront, then payments tied to each delivery checkpoint.
Where fixed price works
Carlos ran a chain of dental offices across Orange County. He needed a patient intake system that replaced paper forms, connected to his existing practice management software, and let patients fill out forms on a tablet in the waiting room. The scope was narrow. The requirements were clear. The integrations were documented.
He got a fixed-price quote for $78,000 with four milestones over 10 weeks. The project came in at $78,000 and took 11 weeks. One milestone slipped by a week because the practice management API had an undocumented rate limit, but that was the vendor’s problem to solve within the fixed price. Carlos paid exactly what he budgeted.
Fixed price is the right call when your requirements are specific, your scope is unlikely to change, and you need budget certainty above everything else.
Where fixed price breaks
Fixed-price contracts create a hidden incentive: the vendor makes more money by doing less work. That doesn’t mean every vendor cuts corners, but the structure rewards it. Some agencies pad fixed quotes by 30–50% to cover their risk. Others define scope loosely enough that “what you expected” and “what the contract says” become two different things.
The bigger problem is rigidity. If you learn something during development that should change the product direction, a fixed-price contract fights you. Every adjustment is a change order. Change orders add cost and delay. Six change orders later, you’ve paid more than time and materials would have cost, and you’ve lost weeks to negotiation.
Pros:
- Budget certainty
- Clear deliverables and timeline
- Vendor carries scope risk
Cons:
- Requires detailed requirements upfront (discovery isn’t free)
- Change orders add cost and friction
- Vendor incentive to minimize scope interpretation
- Not suitable for products where learning shapes the direction
Time and Materials: You Pay for What Gets Built
Time and materials (T&M) is the other end of the spectrum. You pay for the team’s time at an agreed hourly or daily rate. The scope can change weekly. You reprioritize based on what you learn from users, the market, or the first few sprints.
How it works in practice
The vendor assigns a team at agreed rates. Senior developer: $150–$250/hour. Mid-level: $100–$160/hour. Designer: $120–$180/hour. You get a backlog of tasks, the team works through them in order, and you pay for the hours logged. Most T&M contracts include weekly or biweekly reporting so you see exactly where the hours went.
Good T&M agreements include a budget ceiling or monthly cap so costs don’t run unbounded. Bad ones don’t.
Where time and materials works
Nadia was building a marketplace app connecting independent fitness trainers with corporate clients in downtown LA. She had the concept validated through a waitlist of 200 signups, but the product details were still forming. Should trainers set their own rates or should the platform standardize pricing? Should booking be instant or request-based? Should the app handle payments directly or redirect to Venmo?
Every answer depended on user feedback she hadn’t collected yet. A fixed-price contract would have forced her to guess, and she’d have paid for change orders on every wrong guess.
She chose T&M with a $25,000 monthly cap. After the first month, user testing showed that trainers wanted to set their own rates but corporate clients needed standardized invoicing. That single insight changed the billing architecture. Under T&M, the team pivoted in one sprint. Under fixed price, that would have been a $15,000 change order and a three-week delay.
Where time and materials breaks
T&M without discipline is an open wallet. The vendor has no incentive to finish quickly because they’re billing for time, not results. If there’s no cap, no milestone structure, and no accountability for delivery speed, you can spend $200,000 over six months and have nothing shippable.
The phrase “Agile” is often used to justify T&M engagements that lack planning. Agile is a development methodology. T&M is a pricing model. They’re not the same thing. A T&M contract still needs defined goals, delivery milestones, and regular demos of working software.
Pros:
- Maximum flexibility to change direction
- Pay for actual work done
- No change order friction
- Faster start (less upfront specification needed)
Cons:
- Budget unpredictability without caps
- Client carries scope and timeline risk
- Requires active client involvement to manage priorities
- Vendor incentive to extend, not finish
For a deeper look at what drives the hourly rates in T&M contracts, our custom software development cost guide breaks down where the money goes phase by phase.
Dedicated Team: You Rent a Department
The dedicated team model sits between T&M and hiring in-house. You contract a full team (developers, designer, QA, project manager) who work exclusively on your product for a monthly fee. They’re employed by the vendor but function as your team.
How it works in practice
Monthly fees typically range from $15,000–$60,000 depending on team size and seniority. A common setup: one senior developer ($12,000–$18,000/month), one mid-level developer ($8,000–$12,000/month), a part-time designer ($4,000–$6,000/month), and a part-time QA ($3,000–$5,000/month). The team ramps up over 2–4 weeks and stays on your project until you end the engagement.
Unlike T&M, you’re not paying for hours. You’re paying for people. If your senior developer spends two hours debugging a tricky API issue and six hours writing clean code, you pay the same monthly fee either way.
Where dedicated teams work
This model makes sense for product companies that need continuous development over 6–12+ months but don’t want to hire internally. It’s common in Series A and B startups that have product-market fit and need to ship features faster than a two-person founding team can handle.
The economics also work for companies whose software development cost models would show hiring full-time is premature. A dedicated team at $35,000/month costs $420,000/year. Two senior developers in Los Angeles cost $360,000–$440,000 in base salary alone, plus $100,000+ in benefits, equipment, recruiting, and overhead. The dedicated team is comparable in cost but carries no long-term employment commitment, and you can scale down in 30 days instead of going through layoffs.
Where dedicated teams break
You’re paying for availability, not output. If the team has a slow week because your product manager didn’t prepare the next sprint’s tickets, you pay the same. If one team member underperforms, replacing them takes time, and you’re still paying during the transition.
The other risk is vendor lock-in. After 12 months, your codebase is written by people employed by someone else. If the relationship ends, you lose institutional knowledge. Make sure the contract includes documentation requirements and clean handoff terms.
Pros:
- Team continuity and deep product knowledge
- Cheaper than hiring full-time when you factor in total cost
- Scales up or down with 30-day notice
- No per-hour billing anxiety
Cons:
- You pay for availability, not just output
- Requires your own product management capability
- Vendor lock-in risk if handoff isn’t planned
- Minimum 3–6 month commitment typical
Retainer: Ongoing Access Without Full-Time Commitment
A retainer reserves a set number of hours per month at a discounted rate. You use them for bug fixes, small features, security patches, performance improvements, and the steady stream of “can we just add…” requests that every live product generates.
How it works in practice
Typical retainers run 20–80 hours per month at $120–$200/hour (10–20% below standard T&M rates). Unused hours usually don’t roll over, though some vendors allow limited rollover. The vendor keeps a developer familiar with your codebase available so you don’t re-onboard someone every time you need a fix.
Where retainers work
Retainers are the right model after launch. Your product is live, the core build is done, and you need ongoing maintenance plus small improvements. A retainer at 40 hours/month ($6,000–$8,000/month) keeps your software healthy and lets you ship two to three small features per month without the overhead of re-scoping and re-contracting every time.
This is also the right model for companies evaluating freelancer vs agency for ongoing work. A retainer with a development studio gives you the reliability of an agency relationship without the cost of a dedicated team.
Where retainers break
Retainers don’t work for major feature development. If you need 200 hours of work in a month, a 40-hour retainer won’t cover it, and you’ll pay overage rates that exceed what a dedicated team or T&M engagement would cost. Retainers are maintenance vehicles, not build vehicles.
The “use it or lose it” structure also creates pressure to invent work. If you’re paying for 40 hours and only need 10, you’ll find yourself requesting features you don’t really need just to use the hours you’re already paying for.
Pros:
- Predictable monthly cost
- Discounted rates vs. ad-hoc T&M
- Developer familiarity with your codebase
- Quick turnaround on small requests
Cons:
- Unused hours usually expire
- Not suitable for large feature development
- Creates incentive to over-request
- Minimum commitment (usually 3–6 months)
Hybrid: The Model That Actually Matches Reality
Most real software projects don’t fit cleanly into one pricing model. The discovery phase has different risk characteristics than the build phase. The initial build has different needs than the post-launch iteration phase. Hybrid models acknowledge this by combining pricing structures across project phases.
How it works in practice
A typical hybrid structure:
- Discovery: Fixed price ($8,000–$20,000). Clear deliverable: scope document, architecture plan, project timeline.
- Design: Fixed price ($15,000–$40,000). Clear deliverable: approved wireframes, visual designs, design system.
- Core build: Fixed price per milestone. Each milestone has defined deliverables and a set cost.
- Iteration and unknowns: T&M with a monthly cap. Features that emerged during testing or user feedback, handled flexibly.
- Post-launch: Retainer for maintenance and small improvements.
This is how software companies charge when they’re being honest about the nature of the work. Some phases are predictable enough for fixed pricing. Others need flexibility. The hybrid model matches the pricing structure to the risk profile of each phase.
At LC Global Consulting, we use this approach for most engagements. The core build is fixed-scope with milestone payments because clients deserve budget certainty on the work that’s well-defined. Exploratory phases and post-launch work use time-and-materials or retainer structures because forcing a fixed price on unknowns benefits nobody.
How to Pick the Right Software Development Pricing Model
The right model depends on three things: how well you know your requirements, how much budget flexibility you have, and how involved you want to be in day-to-day decisions.
Choose fixed price if:
- You have detailed, stable requirements
- Budget certainty is more important than flexibility
- You’ve done discovery and know exactly what you’re building
- You’ve been through a custom software project before
Choose time and materials if:
- Your product is evolving based on user feedback
- You have a technical team that can manage priorities
- You value flexibility over cost certainty
- You’re building something nobody has built before
Choose a dedicated team if:
- You need 6+ months of continuous development
- You want team continuity without full-time hiring
- You have product management capability in-house
- You’re a startup scaling between Seed and Series B
Choose a retainer if:
- Your product is live and needs ongoing maintenance
- You need 20–80 hours of work per month
- You want quick access without re-contracting every time
- The work is mostly maintenance, patches, and small features
Choose hybrid if:
- Your project has some well-defined parts and some unknowns
- You want the security of fixed pricing where possible and flexibility where needed
- You’re working with a vendor you trust enough for a multi-phase engagement
If you’re not sure which model fits your project, that’s a normal starting point. Schedule a free consultation and we’ll walk through your scope and recommend the structure that protects your budget without locking you into a model that fights your project’s natural shape.
Red Flags in Software Development Pricing
Regardless of which model you choose, these pricing signals should make you pause.
”We can’t give you a number until we start”
Any competent software company can give you a ballpark range after a 30-minute conversation about scope. If they refuse to estimate, they either don’t understand your project well enough or they’re avoiding accountability. A range with caveats is honest. “We have no idea” is a red flag.
Fixed price with no discovery phase
If a vendor quotes a fixed price based on a one-page brief or a single meeting, they’re either padding the price by 40–50% to cover the unknowns they haven’t investigated, or they’ll hit you with change orders the moment reality diverges from their assumptions. According to the Project Management Institute’s Pulse of the Profession report, projects with poor requirements definition are 2.5 times more likely to fail. Fixed price without discovery is a recipe for poor requirements.
Hourly rates below market with no explanation
If US-based agencies quote $50–$70/hour for senior developers when the market rate is $150–$250, the people writing your code aren’t senior, aren’t US-based, or both. Low rates that seem too good are exactly that. The Bureau of Labor Statistics puts the median software developer salary at over $130,000/year, which translates to roughly $100–$130/hour when you add overhead and margin. Anything significantly below that deserves questions.
”Agile” as a pricing model
Agile is a development methodology. It describes how work is organized. It’s not a pricing model. When a vendor says “we do Agile pricing,” they usually mean T&M without milestones, without delivery commitments, and without accountability for output. Agile development can use any pricing model. If the word “Agile” appears in the pricing section of a proposal instead of in the development methodology section, ask what they actually mean.
No milestone payments or deliverable checkpoints
In any model, you should never be more than 4–6 weeks away from seeing working software. If the payment schedule is 50% upfront and 50% at delivery with nothing in between, you have no leverage if things go wrong at month three. Milestone-based payments protect you regardless of whether the overall model is fixed, T&M, or hybrid.
Retainer with no scope flexibility
Some vendors sell retainers that lock you into a specific team for 12 months with 90 days’ notice to cancel. If you’re two months in and realize you need a different skill set or the work volume doesn’t justify the cost, you’re stuck paying for months you don’t need. Look for 30-day exit clauses and the ability to scale hours up or down.
No IP transfer clause
This isn’t strictly a pricing issue, but it shows up in pricing conversations. If the contract doesn’t explicitly state that you own the code, the designs, and the intellectual property upon final payment, the pricing model doesn’t matter. You’re renting, not buying. For a full framework on what to look for when choosing a software development company, our vendor evaluation guide covers contracts, references, and technical diligence.
Questions to Ask Before Signing Any Software Development Contract
These apply to every pricing model:
- “What happens when scope changes?” The answer reveals whether the model has real flexibility or just claims to.
- “How often will I see working software?” Should be every 2–4 weeks maximum, regardless of pricing model.
- “What’s included in the quoted price and what’s not?” Hosting, QA, project management, deployment, and documentation are often assumed by one side and excluded by the other.
- “Who owns the code when the project is done?” The only acceptable answer is “you do.”
- “What does the payment schedule look like?” Milestone-based is the only structure that protects both sides.
- “What happens if we need to end the engagement early?” Know the exit terms before you sign.
- “Can I talk to your last three clients?” Not the three they cherry-pick. The last three.
Fixed Price vs Time and Materials: The Real Comparison
Since fixed price vs time and materials is the decision most buyers face, here’s the direct comparison.
| Factor | Fixed Price | Time & Materials |
|---|---|---|
| Budget certainty | High | Low (unless capped) |
| Flexibility to change direction | Low (change orders) | High |
| Client involvement required | Low during build | High throughout |
| Vendor accountability for delivery | High | Low |
| Risk of overpaying | Moderate (padded quotes) | High (if unmanaged) |
| Risk of under-delivery | Moderate (scope minimization) | Low (you see all hours) |
| Best for first-time buyers | Yes | No |
| Best for experienced product teams | Depends on scope clarity | Yes |
Neither model is inherently better. The right answer depends on your specific project, your team’s capability to manage development, and how much you know about what you’re building before work starts.
The worst outcome is picking the wrong model and discovering it six months and $150,000 in. That’s a conversation worth having before signing, not after.
What LC Global Consulting Uses
We don’t push one pricing model for every project. That would be convenient for us but dishonest toward clients.
For projects with well-defined scope, clear requirements, and stable stakeholders, we use fixed-scope pricing with milestone-based payments. You know the number upfront. You see working software at each checkpoint. If we estimated wrong, that’s our problem.
For projects where the direction depends on user feedback, market testing, or ongoing discovery, we use time and materials with monthly caps and delivery milestones. You get flexibility without the anxiety of an unbounded budget.
For post-launch work, we use retainers that keep a developer familiar with your codebase available for maintenance, security patches, and small improvements.
In every case, you own the code, the IP transfers on final payment, and you’re never more than four weeks from seeing working software.
If you’re comparing proposals from multiple vendors and the pricing models don’t match, that makes comparison difficult. Book a call with our team and bring the other proposals. We’ll help you understand what each one actually covers, even if you don’t end up working with us. Honest advice is how we earn referrals, and referrals are how a boutique studio grows.