The website is about 30% of a web development engagement. Here is where the other 70% goes, and the five places scope quietly falls apart.
The website is roughly 30% of a web development engagement. The other 70% is discovery, integrations, iteration, and post-launch support. Clients budget for the page they can see. Scopes fall apart on the work they cannot.
I have shipped and inherited enough of these projects to know where the gap opens. It is almost never the design. It is the plumbing nobody scoped: the CRM handoff, the third redesign round, the six months after launch when someone has to actually run the thing. This post maps what a web development agency actually delivers against what clients assume they are buying, and names the exact points where budgets and timelines break.
A web development agency delivers a working system, not a set of pages. That system includes discovery and scoping, design, build, integrations with tools you already pay for, content and data migration, testing across devices, launch, and a support window after go-live. The visible website is one deliverable inside that list.
Here is the split I see on a typical $18,000 to $45,000 small-business build:
| Phase | Share of budget | What clients think it is |
|---|---|---|
| Discovery & scoping | 10-15% | "Just a kickoff call" |
| Design & iteration | 20-25% | "The whole project" |
| Build / front + back end | 25-30% | "The whole project" |
| Integrations & data migration | 15-20% | Usually not budgeted at all |
| Testing & launch | 10% | "It just goes live" |
| Post-launch support | 10-15% | Assumed free |
The two rows clients rarely budget for, integrations and post-launch support, are where fixed-price engagements bleed. A CRM connection or a payment flow is real backend work with real failure modes, and it does not get cheaper because the homepage looks done.
Timelines slip because clients underestimate their own side of the work. The agency can build fast. The bottleneck is usually content, approvals, and access to the systems the site has to talk to.
The pattern is consistent. We finish a build ready for real content and get lorem ipsum for three weeks. We ask for admin access to the existing CRM and it takes eight days to find who owns the login. We send a staging link for review and one stakeholder responds, then goes on vacation. None of that is in the Gantt chart, and all of it is on the critical path.
The single most expensive line item in web projects is not code. It is the round trip waiting on a decision that only the client can make. I have watched a two-week sprint stretch to seven because one approval sat in an inbox.
If you want a project to land on time, staff a decision-maker with real authority and get your content and account access ready before the build starts. That alone recovers weeks.
Discovery is the phase where the agency figures out what to actually build before writing code. It is requirements gathering, user flows, technical constraints, and integration mapping. It costs money because it is the phase that prevents the expensive mistakes.
Skipping discovery feels efficient. It is the most common way a project doubles in cost. Without it, you find out in week six that the booking system has to sync two-way with a calendar tool nobody mentioned, and now the data model is wrong. According to the Nielsen Norman Group, fixing a usability or requirements problem after development costs far more than catching it in design, and the ratio only gets worse the later you find it.
Discovery deliverables usually include a sitemap, a list of integrations with their auth methods, content requirements, and a technical approach. If an agency skips straight to mockups with no discovery, that is a flag, not a discount.
Integrations break the scope because each external system has its own auth, rate limits, data shape, and failure behavior that nobody can fully predict at quote time. A single line like "connect to our CRM" can be an afternoon or three weeks.
The usual suspects on a small-business build:
A realistic scope names each integration explicitly. A vague one hides them under "and connect to your existing tools." That phrase is where the change orders live. Here is what a healthy line item looks like versus a landmine:
CLEAR (scopable):
- Push new form submissions to HubSpot as contacts (one-way)
- Map: name, email, phone, source. Retry on 429, alert on failure.
LANDMINE (unscopable as written):
- "Integrate with our CRM"
If your statement of work reads like the second line, get it rewritten before signing. The direction of data flow, the fields, and the failure behavior all change the price.
After launch, the site needs monitoring, security updates, bug fixes, small content changes, and someone to answer when something breaks. Launch is the start of the operating cost, not the end of the project. This is the expectation gap that damages the most client relationships.
Clients often assume the handoff is total: they get the keys, and the site runs itself. Software does not work that way. Dependencies get security patches, third-party APIs deprecate endpoints, browsers change, and traffic spikes expose edge cases. Google's own guidance on web performance treats a site as something you maintain and measure continuously, not a static artifact you ship once.
A good agency offers a support arrangement, usually a monthly retainer in the $500 to $2,500 range for a small business, that covers updates, monitoring, and a set number of change hours. If post-launch is not discussed in the proposal, ask. Silence there means you will be back to negotiate under pressure the first time something goes down.
Fixed-price scopes fall apart at the boundary between what was written down and what the client pictured. The contract says "5 page website with contact form." The client pictured a filterable service catalog, a booking flow, and a blog. Both parties think they agreed.
The five recurring break points:
The fix is not a longer contract. It is a specific one. Named integrations, a revision count per phase, a content responsibility matrix, and a support clause. Pylonworks scopes each of these as separate line items on purpose, and you can see how we structure engagements at https://pylonworks.com. A quote that hides them is cheaper on paper and more expensive by launch.
Before you sign any web development proposal, read it looking for the invisible 70%. Find the line about integrations and make sure each one names a direction and a failure behavior. Find the revision count. Find the content responsibility. Find the post-launch clause. If any of those four is missing or vague, that is your change order forming in advance. Ask for it in writing now, while you still have leverage, not in month three when the homepage looks finished and everyone assumes the hard part is over.
A professional small-business website from an agency typically runs $18,000 to $45,000 for a custom build, with simpler sites lower and complex platforms higher. The range depends far more on integrations and functionality than on page count. A five-page brochure site and a five-page site with a booking system and CRM sync are not the same project.
Scope creep is the gradual expansion of a project beyond what was agreed, usually through small requests that each feel minor. It is the top cause of blown budgets and timelines. The defense is a specific written scope with named deliverables, a revision count, and a change-order process for anything outside it.
Yes. A live website needs security updates, dependency patches, monitoring, and fixes when third-party services change. Most agencies offer a monthly retainer, commonly $500 to $2,500 for small businesses, to cover this. Treating launch as the end of cost is the most common and most expensive client assumption.
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