Short answer
Hourly billing is great for agencies. It's terrible for founders. Here's why we switched to flat-fee pricing, what it structurally changes about how we work, and what it actually means for you.
Every agency I know charges hourly. $80 to $200 per hour, depending on who you talk to and where they're based.
We don't. We charge $6,000 flat for a Custom Software MVP build.
This isn't a marketing decision. It's a structural one that changes the incentives of the entire engagement. Here's what that actually means, and why it matters for you as a founder.
If you would rather have V12 Labs build it, get your free build plan. We will put the scope, timeline, and price range in writing. You keep the plan, and if we build it, you own the code, data, and IP from day one.
Let me be direct about something most agencies won't say out loud.
When an agency bills hourly, they make more money the longer the project takes.
Think through what this means in practice:
Slower developers aren't a problem for the agency. A junior developer who takes twice as long to implement something as a senior developer bills twice the hours. For an hourly agency, this isn't a quality problem, it's a revenue opportunity.
Scope creep doesn't hurt the agency. When you add a feature, or change your mind, or expand the requirements mid-build, every hour spent on those changes is billable. The agency isn't incentivized to push back on scope changes. They're incentivized to say yes.
Complexity is rewarded, not penalized. An over-engineered solution takes more hours to build than a simple, elegant one. For an hourly agency, over-engineering is more profitable than simplicity.
Timeline estimates are padded. Every experienced developer adds buffer to their estimates. For hourly billing, that buffer is billable. A two-week estimate quietly becomes three.
I'm not saying agencies that bill hourly are dishonest. I'm saying the structure creates incentives that are misaligned with what you actually want: fast, lean, right-sized.
Want this built for your business?
We build custom software and AI agents that ship in weeks. You own the code, we stay for support.
Get your free build planFree. 30 minutes. You leave with scope, timeline, and a price range.
When we commit to a flat fee, the incentives reverse completely.
Efficiency is now our problem, not yours. Every hour we spend is an hour of margin we're not recovering. We have a direct financial incentive to work fast and work smart.
Complexity now hurts us. An over-engineered solution costs us more time. We're incentivized to find the simplest thing that works, not the most impressive thing we could build.
Scope creep costs us. When a requirement grows or shifts mid-build, those extra hours come out of our margin. We're incentivized to be precise about scope from Day 1, and to hold the line on it.
Timeline accuracy matters. If we underestimate and the build runs over, we absorb the cost. We have to be honest about timelines because we own the consequences.
Your incentives and ours are aligned. That changes everything about how we work together.
Every agency says "no hidden fees." Here's what we specifically mean:
Included in the $6,000 flat fee:
What creates a new engagement (not a hidden fee, a new scope):
The distinction matters: a bug fix is covered. A new feature requested after the build starts is a new conversation.
If something comes up that might be in a gray area, we flag it before we build it. You will never open a final invoice and see a number you didn't expect.
Flat-fee pricing requires something from you in return: a locked spec.
You can't add features during the build and expect the price to hold. The way we keep costs predictable for you is by agreeing upfront on exactly what we're building and holding both sides to that agreement.
This discipline is actually good for your product. The process of locking a spec forces you to make hard prioritization decisions before the build starts, not during it. It stops you from building things your users haven't validated. It keeps your MVP actually minimal.
The founders who get the most out of flat-fee builds are the ones who come in with clarity. They know what problem they're solving, who their first user is, and what that user needs to do on Day 1.
The founders who struggle are the ones who want to iterate on the product concept during the build. For that workflow, hourly billing might genuinely be better, even if it costs more.
Here's something we've observed across dozens of builds: the founders who go through a rigorous spec process before locking get significantly better MVPs than the ones who treat the spec as a formality.
The spec is where you make your product decisions. Not during the build.
When you have to write down exactly what you're building, every user flow, every screen state, every integration, you discover ambiguities and contradictions in your own thinking. Those are much cheaper to resolve on paper than in code.
Flat-fee pricing creates a natural incentive to get the spec right. You want to make sure everything you need is in scope before you sign. We want to make sure we're not signing up for something vague that expands indefinitely.
The result is a better spec, a better build, and fewer surprises.
I'll be honest about the cases where hourly makes more sense:
When you need to iterate on the product concept during the build. If you're genuinely exploring and expect your requirements to shift significantly, hourly billing lets you change direction without renegotiating scope. It's more expensive, but more flexible.
When you need ongoing retainer work. Maintenance, updates, feature additions over months, hourly billing or a monthly retainer makes more sense than a flat project fee.
When the scope is genuinely unknowable upfront. Some R&D or research-heavy projects can't be scoped accurately before starting. Hourly is honest in those cases.
If you're in any of these situations, we'll tell you in the Discovery Call, and we might not be the right fit, which is fine.
Flat-fee pricing requires three things most agencies don't have:
1. A repeatable process. You can only commit to a flat fee if you've done similar builds enough times to estimate accurately. The first time you build something, you're guessing. The 40th time, you have data.
2. Scope discipline. Agencies that say yes to everything can't charge flat fees because they don't know what they're agreeing to. Flat-fee requires the confidence to say "this is the scope" and hold to it.
3. Trust in your team's speed. Flat-fee is a bet on your own efficiency. If your team is slow, flat-fee pricing destroys your margin. Only agencies confident in their execution speed can make this work sustainably.
We can charge flat fees because we've built enough similar products to estimate accurately, because we're disciplined about scope, and because our team moves fast.
"What if I want to add a feature after the build starts?" We pause, assess the scope change, and have an honest conversation about whether it changes the engagement. Small clarifications, things that were implied by the spec, we absorb. Significant new features get scoped as an add-on.
"What if the product isn't what I wanted after launch?" If the product doesn't match the agreed spec, we fix it. If the spec was agreed and built correctly but you've changed your mind about what you want, that's a new engagement.
"What if I find bugs after launch?" Bugs (things that don't work as specced) are covered post-launch for 30 days. New features requested post-launch are a new scope conversation.
"Why is your flat fee $6,000 specifically?" It's the price point where we can build a well-scoped MVP and make it work sustainably for both sides. It's not arbitrary, it reflects the typical scope of a pre-seed MVP and what our team requires to deliver it at the quality level we're willing to put our name on.
Flat-fee pricing isn't just a pricing model. It's a signal.
It signals that an agency is confident enough to commit. That they've done this before. That they're incentivized to be efficient, not to run the clock. That your interests and theirs are structurally aligned.
The next time you're evaluating agencies, ask each one: "Will you give me a flat fee for this project?"
The ones who won't, ask them why. The answer will tell you more than anything else in the conversation.
Where this fits
Get a clear plan before you spend.
V12 Labs will put the scope, timeline, and price range in writing. If we build it, you own the code, data, and IP from day one.
Related reading
The agency model is rigged against founders. Hourly billing incentivizes slow work, inflated scopes, and dependency. Here's why V12 Labs picked flat-fee pricing, and what we actually stand for.
Why most multi-agent systems break in production, and the architecture we built instead. The Mind, the durable primitives, the learning loop, and the anti-patterns we ran into the hard way.
How Bland.ai and Twilio work together for production AI phone agents, where ElevenLabs-style voice stacks fit, and what teams still need to build.
V12 Labs runs outbound as a staged, evidence-first system: 14 scheduled tasks discover buying signals, review and enrich accounts, draft and verify outreach, enforce approval and sending limits, monitor replies, and learn every week.
Graph engineering is the emerging practice of designing how agents, tools, validators, and humans coordinate across branches, parallel work, shared state, and recovery paths. Here is what is real, what is renamed workflow orchestration, and when a graph is actually worth building.
Loop engineering went from an unknown phrase to the AI industry's biggest buzzword in about a week. Here's what it actually means, where the backlash has a point, and where the practice goes from here.