Why Do Agencies Charge $30,000 for What We Build for $2,500?

Why is custom software so expensive in the published market figures?

Because those figures describe a delivery model built around large, long, fully staffed engagements. Clutch's software development pricing guide, updated September 2026, reports that most software development companies listed on the platform charge $24–$49 per hour, that a typical project runs $10,000 to $49,999, and that the average custom software project costs $132,480 and takes about 13 months to deliver.

Independent guides agree on the shape. FullStack Labs' 2026 Software Development Price Guide reports that 65.7% of custom software projects fall between $30,000 and $100,000, and that only 14.1% come in under $30,000 at the time of writing. DesignRush's pricing guide puts the average at $50,000 to $250,000, noting that some projects reach into the millions.

Read the complexity tiers carefully and one thing stands out. Keyhole Software's 2026 benchmarks put a simple or MVP-scope build at $40,000–$120,000 over two to four months, and Andersen's 2026 guide puts a basic MVP at $25,000–$80,000 over the same period. Every one of those numbers is quoted in months of a staffed team. The unit being priced is team-time, not the software.

That is the consensus our own fixed price band is measured against, and we state it rather than avoid it. An unexplained price twenty times below the market is worth disbelieving. An explained one is worth checking.

Where does a $30,000 agency quote actually go?

Most of it goes to hours that are real, are genuinely incurred, and are not spent writing your software. The largest single driver is utilisation: an agency pays engineers for every working hour but can only invoice the fraction spent on client work.

SPI Research's Professional Services Maturity Benchmark, as summarised by Certinia, reports that billable utilisation across 509 professional services organisations fell to 66.4% in 2025 — the lowest point in the survey's history — with average EBITDA at 9.9%. That figure alone means every billable hour must carry roughly half an hour of paid-but-unbillable time: recruitment, training, internal work, and the bench between engagements.

Stack the rest and the quoted rate builds itself. The inputs below are illustrative and you can change any of them; they are not a claim about a particular firm. The structure, though, is the same at every professional services business that keeps engineers on payroll.

Then count the hours. A conventional build of one core workflow might book two engineers for three weeks, a project manager at a quarter allocation, a short discovery phase and a QA pass. That is 320 billable hours. At $93 an hour it invoices at $29,760 — the shape of the $30,000 quote in the title, assembled entirely from numbers you can see.

HOW A QUOTED HOURLY RATE IS BUILT (illustrative inputs, all shown)

  Engineer cost to the firm (salary, tax, benefits, kit)   $40.00 / paid hour
        |
        |  only 66.4% of paid hours are billable  (SPI Research, 2025 data)
        v
  Cost per BILLABLE hour        $40.00 / 0.664           = $60.24
        |
        |  sales, marketing, admin, office, recruitment ~25% of revenue
        |  operating margin ~10%   ->  delivery is 65% of the invoice
        v
  Quoted rate                   $60.24 / 0.65            = $92.68  (~$93/hr)

  A 320-hour engagement at $93/hr                        = $29,760

Are agencies overcharging for this?

No, and pretending otherwise would be the fastest way to lose a reader who has actually run a business. Every line in that build-up is a real cost of keeping a standing team available, and much of it buys capability a small fixed-price studio genuinely does not have.

The list below is what the higher price is for. Read it as a specification rather than a defence: if three or more of these are things you actually need, the agency quote is the correct purchase and a $2,500 alternative is not a cheaper version of it.

• A standing team you can grow from two engineers to ten next quarter without running a hiring cycle yourself.
• Procurement and compliance capacity: insurance, master service agreements, security questionnaires, SOC 2 and ISO 27001 evidence, data processing agreements.
• Continuity across years, including internal handover so the knowledge does not leave when one person does.
• Willingness to absorb discovery risk — starting work when you cannot yet describe what you want.
• Design and user research programmes rather than interface implementation alone.
• Round-the-clock on-call cover and contractual uptime commitments.
• A balance sheet large enough to stand behind an indemnity clause that means something.

What actually changed in the cost of building the software?

The number of hours a defined piece of software takes, not the price of an hour. In a controlled experiment published by researchers at Microsoft Research, GitHub and MIT Sloan, developers given GitHub Copilot completed a standardised programming task 55.8% faster than a control group — 71 minutes against 161.

That effect is not universal, and the honest version of this argument says so out loud. METR's 2025 randomised controlled trial found the opposite in a different setting: 16 experienced open-source maintainers working on their own repositories, averaging over 22,000 stars and more than a million lines of code, took 19% longer across 246 real issues when allowed to use AI tools, while believing afterwards that they had been 20% faster. How AI-native development changes software pricing works through why both results are true.

The short version is that AI collapses hours on well-trodden, greenfield, narrowly-scoped work and does not collapse them on large unfamiliar codebases. One business workflow on a standard stack sits squarely in the first category. That is also why the price band has a ceiling rather than a sliding scale — the mechanism only works inside a particular kind of scope, and the ceiling is how we stay inside it.

The hours that disappear are typing hours: scaffolding, CRUD endpoints, form validation, test fixtures, admin screens, integration boilerplate. The hours that remain are judgement hours — choosing the data model, catching the authorisation bug the model wrote confidently, hardening the payment path, testing the thing under real conditions. Those are what a senior engineer is for, and our process puts a named one on that review for every build.

What does the same build look like priced both ways?

Here is the comparison with every input visible. The right-hand column is not the same team going faster. It is a different shape of team, with the management layer removed because one senior engineer talks to the client directly and nobody is relaying messages.

Two factors, not one. The hour count falls by about thirteen times because generation is fast and only review is slow. The loading on each hour falls by about 1.6 times because there is no bench to carry, no bid team to fund and no project manager to pay. Thirteen multiplied by 1.6 is roughly twenty, which is exactly the distance between $29,760 and $1,450.

The 25 hours is the number most people disbelieve, so it is worth breaking down. The median build in our catalogue quotes 13 elapsed days, which is nothing like 13 person-days: roughly four hours scoping, ten hours directing generation and correcting output, six hours reviewing and testing, and five hours on deployment and handover, spread across two weeks while other projects run in parallel.

What does $2,500 not buy?

A hard ceiling means saying no, and the list of things outside it needs to be specific rather than gestural. Naming the limits is the point: a price you cannot falsify is not a price, it is a slogan.

What the band does buy is one core workflow with standard integrations, tested and deployed to your own accounts, typically in 10 to 20 days. Larger ideas are split into phases, each shipping something usable, and each phase stays inside the same ceiling. We never quote above $2,500; we quote a smaller first phase instead. The full catalogue of what fits, with prices and timelines, is published at what you can build.

• Compliance programmes — SOC 2 or ISO 27001 audit preparation, PCI Level 1 scope, formal HIPAA validation.
• A dedicated standing team reserved for you, or guaranteed engineering capacity next quarter.
• Round-the-clock on-call cover and contractual uptime SLAs.
• Migrating a decade of messy legacy data out of a system with no documentation and no API.
• Multi-year product roadmap ownership with a rolling backlog and a permanent squad.
• Independent third-party penetration testing — we harden, but we are not an audit firm.
• Anything whose scope genuinely cannot be defined before work begins.

Who should buy a $2,500 fixed-price build?

The model fits a particular buyer, and being precise about that is more useful than claiming it fits everyone. It suits a business that can name the one workflow it wants running differently on Monday: a quotation process, a booking flow, an approvals queue, a report somebody rebuilds by hand every week. The band is $500 to $2,500 because AI drafts the first version and a senior engineer reviews, tests and hardens it, so the scope that fits is one workflow rather than a platform.

It also suits the buyer who intends to own the result outright. Everything lands in your GitHub organisation and your cloud account, so the next developer you hire — or the agency you eventually graduate to — inherits a working codebase rather than a dependency on us. Teams expecting to grow into a larger supplier get more out of this than teams shopping for a permanent partner, which is the reverse of how most studios describe their ideal client.

And it suits anyone testing a hypothesis rather than executing a plan. A median price of $1,450 against a median quoted delivery of 13 days makes it cheap to discover that an idea is wrong, which is the most valuable thing a first build can tell you. The catalogue at what you can build lists every published build if you want to hold your own idea against comparable work.

• Good fit: a small or mid-sized business replacing one named manual process that costs real hours every week.
• Good fit: a founder who needs one workflow live to test demand before committing to a larger engagement.
• Good fit: an operations lead stitching two systems together by hand, where the integration is the whole product.
• Poor fit: a business that wants the supplier to decide what to build, or that cannot free 30 minutes to define the scope.
• Poor fit: anyone who needs the agency capabilities listed above — certification evidence, on-call cover, guaranteed future capacity.

When should you pay the $30,000 instead?

There are cases where the higher quote is straightforwardly the better purchase, and a buyer is entitled to hear them from the cheaper supplier rather than discovering them later.

If none of those apply — and for most small and mid-sized businesses building one workflow, none do — you are paying for a cost structure you will never use. Fixed price versus hourly billing covers who ends up carrying the risk in each model, which is usually the deciding factor.

• Your buyer is a procurement department that requires vendor insurance, security certification and a signed MSA before any work starts.
• The software carries regulated risk — clinical, financial or safety-critical — where audit evidence matters as much as function.
• You need capacity you can grow: eight engineers in six months, not one engineer for three weeks.
• The work is a long modernisation of a large existing codebase, which is exactly the setting where METR measured AI making experienced developers slower.
• You want a partner to own the product roadmap for three years rather than deliver a defined thing and hand it over.
• You genuinely do not know what you want yet, and you want someone else to carry that discovery risk on their invoice.

What mistakes do buyers make when comparing quotes?

Most quote comparisons go wrong in the same seven places. All of them are avoidable with questions you can ask in a single email, before anyone has spent anything.

• 1. Comparing headline prices without comparing hour counts. Ask both suppliers how many engineering hours the number represents; the answers explain the gap faster than any sales conversation.
• 2. Treating an estimate as a price. An hourly quote is a floor, not a ceiling, and the low number on the page is the marketing.
• 3. Assuming the expensive quote includes testing and the cheap one does not. Ask both, then write the answer into the contract.
• 4. Buying capacity you will not use — a standing team of five for a project that needs one engineer for three weeks.
• 5. Ignoring who owns the repository. If the answer is not "you, from the first commit", the price on the page is not the real price.
• 6. Scoping to the budget rather than to the first useful outcome. The right first phase is the smallest thing that changes how the business actually runs, which is the argument in build versus buy.
• 7. Discarding a low quote purely because it is low, without asking the one question that resolves it: what makes it possible? Is cheap custom software too good to be true? is the checklist for that conversation.

PINCLER's perspective: what a published catalogue of 79 builds shows

PINCLER is an AI-first custom software development studio. We build business systems — internal tools, dashboards, booking systems, CRMs, integrations and AI agents — using tools such as Claude, GPT, Cursor and Claude Code, with a senior engineer owning architecture, security and review on every build. Every project is fixed price between $500 and $2,500, and the ceiling does not move.

Across the 79 builds in our published fixed-price catalogue the median price is $1,450 and the median quoted delivery 13 days, with quoted windows running 3 to 30 days. Thirty-three of the 79 are quoted at a fortnight or less. The tooling record is deliberately unglamorous: GPT is listed on 76 of them, Cursor on 75, Claude Code on 63 — and a senior engineer reviews every build before release.

Be precise about what that catalogue is, because the precision is the point. It is a complete published price list, not a record of delivered work: each figure is the advertised band and the quoted window for a build we commit to, computed from the catalogue itself rather than from client invoices. Publishing the whole thing, itemised and checkable, is unusual — most studios publish a range and a contact form. The method behind every number is set out in the fixed-price report.

Set against Clutch's reported 13-month average, the 13-day quoted median is the part that sounds least believable, until you notice it measures a different unit. We are not delivering a 13-month platform in 13 days. We are delivering one workflow, which a traditional engagement would have delivered as sprint three of eleven. Typical builds include a lightweight CRM for a small team, an admin dashboard replacing back-office spreadsheets and a SaaS MVP with authentication and billing.

The bottom line

A $30,000 quote and a $2,500 quote can both be honest descriptions of different production methods. The agency price is dominated by the cost of keeping a standing team available; the studio price is dominated by the hours a senior engineer actually spends. Ask any supplier how many hours their number represents and what those hours go on, and the gap explains itself in about two minutes.

If you want that arithmetic applied to your own brief rather than a worked example, the fixed pricing page sets out what falls inside the band, and a 30-minute call produces a written fixed quote within a working day.