Most web projects that run late do not fail because the code was too hard. They slip because of decisions made, or skipped, in the first few weeks: a vague goal, content nobody owns, a platform chosen for the wrong reason, testing left until the end.
This article covers nine web development mistakes we see business owners and teams make, why each one happens, and what to do instead. None of them needs technical knowledge to avoid. They need attention early, when changes are cheap.
1. Choosing the technology before the job
Why it happens: someone recommends a platform, a competitor uses a particular framework, or the team simply knows one tool well.
What goes wrong: the project bends to fit the tool. A content site gets over-engineered, or an application gets squeezed into a platform that cannot support its rules.
What to do instead: write down users, workflows, integrations and editing needs first, then choose the simplest platform that handles the hardest requirement. Our comparison of CMS and custom web applications walks through that decision.
2. Treating content as a final step
Why it happens: content feels like something to “drop in” once the design is finished.
What goes wrong: layouts are designed around placeholder text that is shorter, longer or differently structured than the real thing. Launch waits for copy, images and product data that nobody was assigned to produce.
What to do instead: name an owner for each content area at the start. Design with real or realistic content. Put content deadlines in the project plan alongside development milestones.
3. No written acceptance criteria
Why it happens: everyone assumes they share the same picture of “done”.
What goes wrong: at review time, the client expected one behaviour and the developer built another. Both can point to the brief and be right.
What to do instead: for each important feature, agree a testable statement before building it. “The enquiry form sends a copy to the sales inbox and shows a confirmation message” is checkable. “A good contact form” is not.
If nobody wrote down what “done” means, every review becomes a negotiation.
— VSN Editorial
4. Too many decision-makers, or none
Why it happens: several departments care about the site, and nobody wants to leave anyone out.
What goes wrong: feedback arrives late, contradicts itself or reopens decisions already made. Alternatively, nobody has authority to approve, so the project stalls.
What to do instead: name one decision-maker with authority to approve scope and designs. Collect input from others before review deadlines, not after. Share that person’s name with the development team so everyone knows whose approval counts.
5. Underestimating integrations
Why it happens: on a feature list, “connect to our CRM” looks like one line.
What goes wrong: the CRM’s API turns out to be limited, the payment provider needs extra verification, or nobody has the account credentials. Integrations become the critical path.
What to do instead: for every integration, confirm early that access is possible, who owns the account, what it costs and what should happen when the other system fails. Test against the provider’s sandbox where one exists.
6. Leaving performance until the end
Why it happens: speed is assumed to be something you can tune just before launch.
What goes wrong: heavy images, unnecessary scripts and layout choices are baked into every template, and fixing them late means rework.
What to do instead: set performance expectations at the start and check them during the build. Google’s Core Web Vitals give a useful shared vocabulary. Google describes a good experience as Largest Contentful Paint within 2.5 seconds, Interaction to Next Paint under 200 milliseconds and Cumulative Layout Shift under 0.1, as explained in its guide to Core Web Vitals. Good scores support user experience; they do not guarantee rankings.
7. Ignoring accessibility
Why it happens: accessibility is seen as a specialist concern or a later enhancement.
What goes wrong: some visitors cannot use navigation, forms or content, for example people using a keyboard or a screen reader, or people with low vision. Retrofitting fixes across finished templates costs more than building them in.
What to do instead: agree accessibility expectations in the brief, design with sufficient colour contrast and clear focus states, and include basic accessibility checks in testing. The W3C’s Web Content Accessibility Guidelines overview is the standard reference.
8. Testing only the happy path
Why it happens: reviews follow the demo route: everything filled in correctly, on a fast connection, on one browser.
What goes wrong: real users submit half-finished forms, use older phones, lose connection mid-checkout or try to access pages they should not see. Problems appear after launch, when they are more visible and more expensive.
What to do instead: test error states, empty states, permissions and the agreed browsers and devices. Ask a few people who were not involved in the project to try the key tasks.
9. Forgetting ownership and handover
Why it happens: accounts are set up quickly in whoever’s name is convenient.
What goes wrong: the domain, hosting, analytics or a paid plugin sits on a former supplier’s account. Renewals lapse, access is lost and changing developers becomes difficult.
What to do instead: keep domains, hosting, repositories and paid services in your organisation’s name wherever practical. Ask for handover documentation as part of the scope. Plan ongoing care too; our guide to website maintenance cost lists what to budget for.
If your project is already off track
Spotting one of these mistakes mid-project is common, and it is usually recoverable. Pause before adding more work and reset the basics:
- Write down what has been agreed so far and what is still open.
- Confirm who has authority to make the remaining decisions.
- Agree acceptance criteria for the features still in progress.
- List outstanding content, access and integration dependencies, each with an owner and a date.
- Re-plan the remaining milestones against that list, and move non-essential features to a later phase.
A short reset meeting with these five points often does more for a late project than extra development hours.
A self-check to avoid web development mistakes
- We can describe the users and their main tasks in a few sentences.
- Each content area has an owner and a deadline.
- Key features have written acceptance criteria.
- One person has authority to approve scope and design.
- Every integration has confirmed access, an account owner and a failure plan.
- Performance and accessibility expectations are written into the brief.
- Testing covers errors, permissions, browsers and devices.
- All accounts and credentials will be in our name at handover.
Key takeaways
- Define the job before picking the technology.
- Assign content owners and deadlines from day one.
- Write acceptance criteria so reviews are objective.
- Confirm integrations, performance and accessibility expectations early.
- Keep accounts in your own name and plan the handover.
Questions about avoiding web project problems
What is the most common cause of web project delays?
Late content and slow decisions are among the most common causes. Both are easier to prevent than technical problems: assign owners, set deadlines and name one approver.
Should accessibility be part of a small business website project?
Yes. Basic accessibility, such as readable contrast, keyboard-friendly navigation, labelled forms and meaningful image descriptions, is easier to build in from the start than to add later.
Do good Core Web Vitals scores guarantee better Google rankings?
No. Google recommends good Core Web Vitals for user experience and Search, but they are one part of page experience among many ranking considerations.
How can I tell if my developer is testing properly?
Ask what will be tested, on which browsers and devices, and how defects are reported and fixed. A proposal should describe testing activities, not just promise quality.
VSN documents milestones, acceptance checks, client inputs and change handling before implementation starts, so these mistakes surface early. See our web development service or share your project brief.
Filed under Software



