Flat-Fee vs Hourly Software Development: What You Pay

How hourly billing works against regulated projects

Time-and-materials billing is the default in custom software for a reason. Scope is genuinely unknowable on a lot of engagements. A founder shows up with a sketch and three Loom videos. The team starts pulling on threads. Half of what looked simple turns out to be hard; half of what looked hard turns out to be a Stripe import away from done. Hourly is honest about that ambiguity. The client pays for thinking time, and the thinking is the work.

Hourly starts to fail when the work is not actually ambiguous. The shape of an audit-logging table is known. The structure of a HIPAA Row-Level Security policy is known. The path for a SEC EDGAR filing submission is known. When the answer is "build the posture once, correctly," the meter is billing the buyer for the engineer's second attempt, the debugging time on the first one, and the wasted iteration the team would have eaten on a fixed fee. The client's incentive is for the work to be fast and right. The engineer's incentive, on hourly, is for the work to be thorough. Those two incentives are not the same thing.

Regulated work compresses the case for flat fee software developmentfurther, because the buyer's compliance counsel needs a known scope to sign off on the engagement. A HIPAA-grade build, a SEC EDGAR filing system, a privileged legal workflow: these all require a written posture that counsel reads before the work starts, not a meter that keeps running until the auditor calls. Compliance reviewers do not bill hourly for compliance posture; they bill for an outcome. The software that supports the posture should match that model.

The reason flat-fee was historically rare is that the up-front scoping work (the part where someone senior reads the brief, asks the right clarifying questions, and writes down what the build actually is) costs money. Most agencies pushed that cost into a billable discovery phase. Cardinal does the up-front read for free and returns a written scope plus flat number in two business days; the economics of flat-fee SaaS in 2026 covers why AI-accelerated delivery makes that math work in a way it did not five years ago.

What a flat-fee scope actually requires from the buyer

The honest part of flat-fee billing is that it depends on the buyer being able to say what they want. Most founders cannot. They write half a scope, record three Loom videos, and ship the rest as hope. That is not a character flaw. Naming the build precisely is hard, and a lot of the clarity only shows up once a senior engineer reads the brief and asks questions the founder did not know to ask themselves.

Cardinal's written quote, returned within two business days, is the artifact that closes that gap. The intake takes a brief in whatever shape it arrives (two paragraphs, a sketch, a Loom, a finished PRD) and returns three things: clarifying questions in writing, a written scope that lists what is in and what is out, and a flat fee against that scope. Mutual NDA countersigned the same day if the brief is sensitive. No discovery call required.

The written quote is the scope; the scope is the contract.

Once the engagement starts, the flat fee covers the agreed scope without surprise invoices. If something changes mid-build (a new screen, a new integration, a different compliance posture than the original brief called for), it gets re-quoted in writing before any new work happens. The client sees the change as a number, decides yes or no, and the engagement either expands at a known price or ships against the original scope. No retainer-creep. No end-of-month invoice that is bigger than expected. The number you accepted is the number you pay for the work described.

This works because the up-front read is real. Cardinal reads the brief carefully enough on day one to be willing to bid against it on day two. If the brief is too vague to scope honestly, the response is questions, not a number. The flat fee is a promise the studio can keep because the scoping work happened before the meter would have started.

When hourly billing is the right call

Flat-fee is not the right model for every engagement. Pretending otherwise is the kind of sales line that makes buyers stop trusting the studio that says it. There are three patterns where hourly or T&M is the more honest answer.

True R&D. If the engagement is novel ML model training, an unsolved algorithmic problem, or a regulatory negotiation where the path is not yet clear, scope is not knowable in advance. A senior engineer is thinking through an ambiguous problem with the buyer, and the thinking is the deliverable. Hourly bills for that thinking honestly. Flat-fee would either be a wild-guess number that is wrong in one direction or a padded number that is wrong in the other.

Open-ended UX iteration.If the buyer wants infinite revisions on the look and feel without naming a stopping point, flat-fee turns adversarial fast. The studio is incentivized to ship; the client wants one more pass. Either the scope names a finite number of design rounds (Cardinal's does), or the engagement should be priced hourly so the meter and the iteration count are aligned.

Ongoing operational work. Hosting, monitoring, on-call response, monthly feature increments, content updates: none of these are scoped deliverables. They are an operational relationship over time. The honest model is a retainer, not a flat fee per ticket and not a time-and-materials trickle. Cardinal handles ongoing work through flat monthly retainers for the same reason: the buyer wants a known monthly number, not an end-of-month surprise.

The principle underneath all three: if you are paying a senior engineer to think through an ambiguous problem with you, hourly is the honest model. If you are paying for a known deliverable, hourly is just slower and more expensive than flat-fee against the same scope. The failure mode in the market is hourly billing applied to known deliverables because the studio either cannot scope up-front or does not want to commit to a number. That is where flat-fee wins on price and timeline both.

What Cardinal's pricing actually covers

Cardinal Stacks sells four flat-fee software development engagements. Each one ships against a written scope, with a fixed timeline and a fixed number. The fees below are the published starting points for each tier: Cardinal's custom software pricing for 2026 in one place. Read them as what each tier buys, in buyer terms.

• Prototype Sprint: $1,800 flat, 5–7 days. An idea, sketch, or memo turned into a working prototype on a temporary domain. Real flow, real interactions, real data. Useful for testing a concept before committing to the production build, or for showing an investor what the product looks like running.
• Vibe Rescue: $4,800 flat, 14 days. Production hardening for an app already built in Lovable, v0, Bolt, or Cursor. Authentication, secret management, Row Level Security, audit logging, error monitoring, deployment to the client's domain. Same app on top; different layer underneath. See Vibe Rescue for the full scope.
• Signature Site: $3,200 flat, 7–10 days. Hand-built launch site at the client's domain. Brand voice copywriting, custom design, on-page SEO with AIO and GEO baseline. No template kits, no bento grids, no stock photography.
• Flagship Build: from $7,500, 2–5 weeks. Full custom application. Basic from $7,500 (5–10 pages), Advanced from $12,000 (10–25 pages), and Enterprise / regulated from $28,000 (25–40+ pages, HIPAA, SEC, legal, audit-trailed document workflows). See Build & Run for the tier breakdown.

The "from $28,000" price on regulated Flagship Builds is worth being explicit about. It is more expensive than a $7,500 basic Flagship because the regulated tier carries additional posture work: a countersigned BAA where HIPAA applies, immutable audit logging configured into the database layer, role-based access control enforced in code rather than UI, a documented breach-response runbook, and a written posture artifact the buyer's compliance counsel can sign off on. That is real work, and it is where the cost of regulated software development actually lives. The price comes from the posture, not the page count.

Every Cardinal engagement, at every tier, includes the same baseline: mutual NDA countersigned the same day, written scope and flat fee returned within two business days, no discovery call required, no hourly billing at any point, and 30 days of free fixes after handoff. Scope changes during delivery get re-quoted in writing before any new work starts. The number on the original engagement covers the original scope and does not move.

One framing worth being clear about: flat-fee at these numbers is enabled by AI-accelerated delivery. Parallel agent orchestration, code generation handling the boilerplate, senior engineers spending their time on architecture and compliance posture rather than typing. The cost basis would not support flat fees at this scale without that delivery model. The companion post on flat-fee SaaS development in 2026 covers the gross-margin math in detail. The cost basis only works because senior engineers are spending their time on architecture, not boilerplate. That is what the number reflects.

Cardinal does not bill hourly, does not run discovery calls, and does not require a retainer to start. If the engagement turns out to be one where hourly genuinely is the right model (true R&D, an unscopable exploratory phase), the response on intake is to say so rather than quote a flat fee against a brief that should not be flat-fee scoped. Honesty about which model fits the work is part of the offer.

If you have a project you want quoted, the intake takes a brief in any shape it arrives. Send the brief for a free written quote and the scope plus flat number comes back within two business days. Mutual NDA same day, no discovery call, no obligation if the response is to recommend a different model than Cardinal sells.