How fixed-fee projects work

The figure on the scope is the figure on the invoice.

That sentence is the entire product. This page is the agreement behind it: what we put in writing before any money moves, what we ask you to bring to the first call, and what happens when the project changes mid-build. Ten minutes here saves both of us a bad quarter.

We're the devs who do the work, not account managers who talk about it. Shopify design, development, and CRO, from your first store to Shopify Plus.

Bring us your project

45 minutes with Justin, the developer who scopes and builds the work. Read this page first and the call moves twice as fast.

Fixed fee has a bad name. Both sides of the table earned it.

You've probably lived the buyer's version: the price was fixed until it wasn't. A clean number wins your signature, then the bleed starts. Small invoices for things you assumed were included. An hourly meter idling behind the flat fee. A final bill that turns the quote into fiction.

There's a seller's version too. A price agreed for ten pages gets quietly asked to cover eighteen, and every quick addition is paid for out of the quality of the pages that were actually scoped. It's why so many shops flinch at the words fixed fee, then pad their quotes to cover the flinch.

Both versions are the same failure: nobody wrote the scope down like it mattered.

Serious professions settled this long ago. A law firm opens a matter with an engagement letter. An accountant will not flat-quote "just handle the finances." The document that states exactly what is covered is what makes a flat price possible in the first place. Ours is called a scope of work, and the build that runs your revenue deserves the same paper as your books and your contracts.

The scope of work is the product

Before any money moves, you get a scope of work. It's short, it's specific, and every line in it is checkable:

You sign it. We sign it. Then we build exactly that, and the figure on the scope is the figure on the invoice. Not a starting estimate. The figure.

Now read it from the other side: if something is not in that document, it is not in the price. There's no fine print, because the SOW is the print. That's the only version of fixed fee that's honest in both directions.

Web design packages start at $2,400, $4,800, and $28,000, one-time, matched to your store on the discovery call. Where hourly billing applies instead, the rate and the reasons are published too.

What we ask you to bring

Come with a thought-out project. That's the entry fee, and it's the only one.

Four answers, before the call:

  1. Your pages. Which ones, and what each needs to do. A list, not a sitemap.
  2. Your content. Written, half written, or not started. Copy status moves scope more than any design decision.
  3. Your integrations. Subscriptions, reviews, loyalty, ERP, the apps wired into your checkout. Name them.
  4. Your decision maker. The one name that approves design. If it's a committee, say so up front; committees get scoped differently, and that's fine.

Notice what's not on the list: a spec. You don't need wireframes or a requirements document. "Nine pages rebuilt, copy is 80 percent written, Recharge stays, I approve designs" is a project we can quote fixed by the end of one call. "We need a new site" isn't a project yet, and any firm that puts a flat number on it is guessing with your money.

If yours is still loose, that's a stage, not a failure. We'll scope the shaping work as discovery or hourly first, and get you to something a fixed price can honestly cover. What we won't do is quote a moving target and bill the difference later where you can't see it.

Worth noticing: the operators who show up with those four answers are the ones whose projects ship on time and on budget. That's not a coincidence; it's the same discipline. This page filters for it on purpose.

Changes are welcome. Changes are priced.

Both sentences, always together. That's the whole rule.

Mid-build ideas are normal. Good builds cause them: the staging link goes up and you realize the story page should be two pages, or the bundle app you've been waiting on finally ships. When that happens:

  1. We confirm it's outside the scope of work, usually the same day.
  2. We write a change order: what it is, what it costs, what it does to the timeline.
  3. You approve it in writing, park it for after launch, or decline it. No work happens while you decide.

Decline it and it disappears, no hard feelings, no effect on the original scope. Approve it and we build it, in that order, every time.

Smaller changes bill at our standard rate of $135 an hour. Larger ones get their own fixed quote, under the same rules as the project itself. Either way, you see the number before the work happens.

The rule points both directions, which is the part most agencies skip. We don't get to grow the project either. If we hit something mid-build we believe the store genuinely needs, you get the same written quote and the same free choice, including no. An agency that surprises you with extra work is running the same play as one that surprises you with an invoice.

The discipline is what makes the price real

A fixed price can only stay fixed because the scope is fixed. Loosen either one and the other follows; the only question is which side quietly eats the difference.

So look hard at "flexible." When an agency absorbs every mid-build request with a smile and no quote, that flexibility was funded somewhere: padded hours on the next phase, a project management line that grew, a reconciliation invoice at the end, or a build that got thinner in the places you couldn't inspect. The generous yes is a billing strategy. It just invoices later, or it already did.

Typical agency rates now run $150 an hour and up, and the layered shops move at layered speed. Our rate is $135, published, and the work ships dramatically faster because the person who quoted it is the person building it. The build timelines published on the web design page are the receipt. We can hold that line for one reason: nothing unpriced enters the pipeline. Ever. The change-order rule isn't a footnote on the fee. It's why the fee can be trusted at all.

Better than a freelancer. Faster than a firm.

A freelancer quotes from optimism and renegotiates from a corner. A big firm quotes from a rate card with the padding already inside. One signed page of scope is the middle path: small-team speed, grown-up paper. It's also why week six of our projects is about the build, not about re-litigating week one.

Fixed fee or hourly? Pick in one minute

A fixed fee is a fixed scope, priced on the hours we can see. That sentence decides everything below.

Your situationThe right toolWhy
The scope is defined: page list, features, what done looks likeFixed feeThe SOW locks the figure. What we quoted is what you get, in writing.
Small changes, tweaks, a punch listHourly at $135Quoting every tiny item costs more than it protects. Estimated in writing first, a running log, a cap you set.
A big idea that isn't thought through yetPaid discovery firstWe map a functional requirements document (an FRD) together: pages, features, integrations, what done looks like. That work takes real time, so it's scoped and priced like work. Then a fixed fee actually means something.
Work that evolves as we learn (CRO, ongoing iteration)The retainerA moving target and a fixed price can't both be honest. $3,200 a month, minimum three months: watch, fix, measure, repeat.

Ask for a fixed fee on a loose scope and one of two things happens somewhere: you overpay for invisible padding, or the vendor quietly eats it and the build quality pays for it. We don't run either play. We scope it, we price it, we put it in writing, and changes get their own numbers.

Matching the instrument to the work is the job. A firm that sells fixed fee on exploratory work either can't tell the difference or intends to profit from it.

If you'd rather build it yourself

Some store owners want to run the build themselves, and some of them should. The work is learnable. It isn't casual, and the distance between those two sentences is everything this page just walked through.

We're putting together a course that teaches our process end to end: how we scope, how we design, how we build, in the order we do it. If that's your route, you'll be running the same playbook we run. Either way, the advice on the call is straight, including "you could do this part yourself."

Questions worth asking before you sign anything, anywhere

What counts as a change?

One test: is it written in the scope of work? A ninth page when eight are listed. A third revision round when two are counted. An integration nobody named. New copy after copy approval. All welcome, all changes, all quoted in writing before the work happens. The mirror image holds too: if it is in the SOW, it's covered, and you will never hear otherwise.

What if I'm not sure what I need yet?

Say exactly that on the call. It's the most useful sentence in discovery. We'll scope the thinking as discovery or hourly work and get you to a quotable project before anyone attaches a fixed number. The people who get burned by fixed fee are almost always the ones who let someone quote it too early.

What if we discover something mid-build?

Real projects surface real surprises: a theme rotted under the surface, an app whose API doesn't match its docs. Two cases. If we should have caught it in discovery, that's ours, and we eat it. If nobody could have caught it, we stop, show you what we found, and put options with numbers in front of you before any extra work happens. You decide. What we never do is absorb it silently, because that cost comes out of your build quality, or bill it silently, because that cost comes out of trust.

Can I add pages later?

Please do. A growing store should. Mid-build, it's a change order with a written price. After launch, it's a small scoped project of its own. Adding pages was never the problem in this industry. Adding them without a number attached is.

Why not build in a buffer so small stuff is just covered?

Because you'd be paying for the buffer. An agency that "absorbs" changes priced them in before you signed. You just never saw the line. We quote the real scope tight and price changes when they exist, which means you only ever pay for things you actually asked for. It also keeps quotes honest between clients: nobody subsidizes anyone else's indecision.

What happens if my content is late?

The timeline moves and the price doesn't. Late copy and missing photos stall more builds than anything technical, which is why the SOW names your content dependencies and their dates up front. We flag a slip the week it happens, not at the end. If you'd rather we produce the missing content, that's a change order like anything else, quoted before we write a word.

Honestly, isn't this a lot of process?

It's one document you can read over a coffee, and it's the last process conversation the project needs. The "flexible" alternative runs on process too; you just don't see it until it arrives as an invoice. Ten minutes of reading against a quarter of surprises is the best trade on this page.

Come with a project. Leave with a price.

Bring the four answers: pages, content, integrations, decision maker. You get 45 minutes with Justin, the developer who will scope and build the work. If your project can carry a fixed price, you leave knowing which package fits and what discovery will pin down. If it can't yet, you'll hear that too, along with the shortest path to a scope that can.

There's no sales rep to hand you to, and the rules won't change after you sign. You've already read them.

Real Partners. Real Builds. Real Growth.