The real numbers behind our fixed-scope and retainer pricing, what drives cost up or down, and why AI tooling changed our internal economics without changing your quote.
Pylonworks prices web projects one of two ways: a fixed-scope build (most land between $6,000 and $30,000) or a monthly retainer ($2,500 to $8,000). What moves the number is scope clarity, third-party integrations, and how many revision rounds you want. AI tooling cut our internal hours. It did not cut the price, and I'll explain why.
I've quoted a lot of web projects. I've also watched a few of them go sideways because the pricing model was wrong for the work, not because the number was wrong. So this post is the actual model we use at Pylonworks, with the real ranges attached. If you're a founder trying to budget a build, you should be able to read this and predict your own quote within a few thousand dollars.
We price on scope certainty, not on hours. When the deliverable is well defined and unlikely to change, we quote a fixed number. When the work is open-ended or ongoing, we quote a monthly retainer. That single decision, made in the first call, sets everything downstream.
The reason is risk allocation. A fixed-scope quote means we absorb the risk of underestimating. We can only do that safely when the scope is nailed down: defined pages, defined integrations, a signed-off design direction. The moment the work is "we'll figure it out as we go," a fixed price becomes a guess, and a guess either overcharges you to cover our risk or underpays us into cutting corners. Neither is good for a long relationship.
The most expensive pricing mistake I see is a fixed-price contract wrapped around a vague scope. Somebody eats the difference every time, and resentment is a worse outcome than a slightly higher quote.
So the first thing we do is figure out which bucket you're in. Most marketing sites and standard web apps are fixed-scope. Ongoing product work, frequent experiments, and "we need a dev partner for the next year" are retainers.
Fixed-scope is a defined project with a defined price and a defined end. A retainer is a recurring monthly block of development capacity with no fixed endpoint. Here's how they compare on the things that actually matter to a budget.
| Factor | Fixed-scope build | Monthly retainer |
|---|---|---|
| Typical range | $6,000 to $30,000 | $2,500 to $8,000 / month |
| Best for | Marketing sites, defined web apps, redesigns | Ongoing product work, frequent changes |
| Who holds scope risk | Us | You |
| Change handling | Change order, re-quoted | Reprioritize next sprint, no re-quote |
| Commitment | One project | Rolling monthly, 30-day out |
| Predictability | High on price, lower on flexibility | High on flexibility, lower on total cost |
A quick gut check: if you can write down every page and feature today and it won't change much, go fixed. If your roadmap is a moving target and you value being able to change direction next week, the retainer costs less friction over a year even if the monthly number looks bigger.
The number moves on four things, roughly in order of impact: scope size, integrations, design source, and revision rounds.
Scope size is obvious but people underestimate it. A five-page marketing site and a fifteen-page site with a blog, gated content, and a customer portal are different orders of magnitude. Each unique page template is real design and build time.
Integrations are the quiet budget killer. A contact form is nothing. A Stripe checkout with subscription logic, webhooks, and a customer billing portal is a week of careful work because the failure modes involve real money. Every external system you connect (payments, a CRM, an auth provider, a booking tool) adds a testing surface. I quote integrations as line items so you can see exactly what each one costs and drop the ones that aren't worth it.
Design source matters more than clients expect. If you bring a finished Figma file, we build to it and the quote drops. If you need us to design from scratch, that's discovery, wireframes, and revision cycles on top of the build. Both are fine. They're just priced differently.
Revision rounds are where scope quietly balloons. We include two rounds of revisions per phase in a fixed quote. Unlimited revisions sound generous until they turn a three-week project into a three-month one, so past the included rounds we bill hourly and tell you before the meter starts (see scope quietly balloons) (see scope quietly balloons).
Here's roughly how those factors stack into a real quote:
Base 5-page marketing site $6,000
+ Custom design from scratch +$3,500
+ Stripe subscription checkout +$2,500
+ Blog/CMS integration +$1,800
+ 3rd revision round (est.) +$900
-----------------------------------------
Estimated total $14,700
You can look at that and cut the CMS or bring your own design and watch the number drop. That's the point. Transparent line items let you steer.
This is the question I get most from other developers, so I'll answer it plainly. AI tooling cut our internal build hours on a typical project by something like 30 to 40 percent over the last two years. We kept the client-facing prices roughly flat. Here's the reasoning.
First, the value we deliver did not drop. A working checkout flow is worth the same to your business whether it took me 40 hours or 24. Pricing on our internal effort instead of your outcome would be leaving money on the table and, more importantly, training clients to think of us as an hourly commodity.
Second, the hours AI removed were the wrong hours to bill for anyway. Boilerplate, config, first-draft component scaffolding, test stubs. The hours it did not remove are the ones that were always the actual job: understanding your business, making judgment calls on architecture, catching the edge case in a payment flow before it bills a customer twice. If anything the ratio of judgment to typing went up, and judgment is what you're paying for.
We also spend real money running these tools in production. Frontier models are not free. Anthropic's published API pricing and the general economics of running agents at scale mean a heavy build has a real inference cost line, even if it's small next to labor. That cost lives on our side of the ledger.
What did change is our capacity. We take on more projects with the same team, and we can afford to be pickier about fit. The efficiency showed up as throughput and margin, and a bit of it flows back to you as faster delivery. A five-page site that took four weeks in 2023 ships in about two and a half now. Google's own web.dev guidance on performance budgets hasn't gotten easier to hit, so the saved time goes into doing that work properly rather than skipping it.
Here are honest ranges for the projects we quote most often. These assume you bring reasonable clarity on what you want.
If your budget is under $5,000, I'll usually tell you a good template on a platform like Webflow or Framer gets you 80 percent of the way for a tenth of the cost, and I'd rather send you there than take a project that can't succeed at that budget. Build-vs-no-code is a real decision, and the honest answer sometimes points away from us (see Custom Build vs No-Code for a Client Site: How to Decide).
Most custom marketing sites land between $8,000 and $16,000, and web app MVPs run $18,000 to $35,000. The exact number depends on scope size, integrations, whether you bring a design, and how many revision rounds you want. We quote line items so you can see and adjust each piece.
For a defined, one-time project, fixed-scope is almost always cheaper in total. A retainer is cheaper in friction when your roadmap changes often, because you reprioritize each sprint instead of re-quoting every change. Pick based on how stable your scope is.
Not directly on the price tag. AI cut our internal build hours by 30 to 40 percent, which we reinvested into faster delivery and higher capacity rather than lower quotes, because the value of a working site to your business is unchanged. You feel it as speed and availability more than as a discount.
Integrations. A static site with a contact form is inexpensive. Add Stripe subscriptions, a CRM sync, or custom auth and each one adds real testing time because the failure modes involve money or data. Cut the integrations you don't need and the number drops fast.
The practical next step: before you ask anyone for a quote, write down every page and every external system you want connected. Bring that list. A tight scope is the single biggest lever you control on the final price, and it takes an afternoon.
Tired of re-keying the same data between tools? Pylonworks builds custom automation and internal tools for businesses without a developer, on a fixed quote you approve up front. Tell us what's eating your time