Hiring a developer you haven't worked with before means trusting a process you can't see — until something goes wrong and you find out the hard way what was never actually planned. The fix is simple in principle: a documented, predictable process that's the same for every project, communicated up front instead of discovered along the way. This breaks down exactly what happens at each of the five phases between your first message and a live site.
- The brief gets locked before development starts, not adjusted mid-build
- Design happens entirely in Figma before any code gets written
- SEO and performance work is built into the development phase, not added afterward
- QA happens across every major browser and device before a client sees staging
- Launch includes full credential handover — no dependency on the developer afterward
Phase 1: Discovery and Brief Confirmation
Within 24 hours of receiving a complete brief, scope, timeline, and any open questions get confirmed in writing. Development doesn't start until the brief is locked — an unclear brief is the single biggest cause of project delays and scope disputes, so this stage gets real time instead of being rushed to "get to the fun part."
What Counts as a Complete Brief
A complete brief includes your goals, target audience, page content and copy, images, a reference site or design direction, your sitemap, and target keywords per page. Missing pieces get flagged here, not discovered three phases later.
Phase 2: Figma Design
Full Figma mockups get produced for every page — desktop and mobile — shared directly for review with no agency-style relay through an account manager. Revisions continue with no artificial cap, because catching a design problem at this stage costs minutes; catching the same problem after development costs days.
Why Design Happens Entirely Before Development Starts
Sequencing matters here. Design decisions made mid-development are expensive because code already built around the old layout has to be unwound. Locking design before development starts removes that cost entirely.
Phase 3: Staging Development
Development begins the day design is approved, on a private staging environment that's visible throughout the build rather than a black box until "done." SEO architecture, schema markup, image optimization, and page speed work all happen during this phase — not bolted on at the end, which is the difference between a fast site and a site that's fast everywhere except the pages built under deadline pressure.
This phase is also where the build pace described in how a 20-page site gets built in 5 days actually plays out — the same structured sequencing, just compressed when the brief allows it.
Phase 4: QA Testing
Every build gets tested across Chrome, Firefox, and Safari on desktop, tablet, and mobile before a client sees it — broken layouts, slow-loading images, and console errors get caught here, not reported by a customer after launch. Accessibility matters at this stage too: the W3C's Web Accessibility Initiative guidelines provide the baseline standard most professional QA processes check against, covering things like proper heading structure, color contrast, and keyboard navigation that benefit every visitor, not just those using assistive technology.
Performance Gets Verified, Not Assumed
Page speed and Core Web Vitals get checked against real benchmarks before launch, following the same Google page experience criteria that affect search visibility — confirming the performance work done in Phase 3 actually holds up under testing, not just in theory.
| Phase | What Happens | Typical Duration |
|---|---|---|
| 1. Discovery | Brief confirmed, scope and timeline locked | Within 24 hours of a complete brief |
| 2. Figma Design | Full desktop and mobile mockups, unlimited revisions | Varies by project size |
| 3. Staging Development | Build with SEO and performance built in | Varies by project size |
| 4. QA Testing | Cross-browser, cross-device, accessibility, performance checks | Before any client review |
| 5. Launch & Handover | Live migration, full credentials and documentation | Same day as final approval |
Phase 5: Launch and Handover
Migration to the live domain happens with DNS handled if required, followed by full credential and documentation handover. The site stays fully in your control — no dependency on the developer to make basic future changes, and no held-hostage hosting or domain access.
- Brief locked before development, preventing scope creep mid-build
- Unlimited design revisions before any code is written
- SEO and performance built in during development, not retrofitted
- Cross-browser, cross-device, and accessibility QA before launch
- Full credential handover — no vendor lock-in after launch
- Starting development before the brief is genuinely complete
- Skipping structured QA to hit an arbitrary deadline
- Retrofitting SEO and performance work after launch instead of building it in
- Withholding credentials or access after a project is paid for
What Happens If You Need a Change Mid-Project
A locked brief doesn't mean zero flexibility — it means changes go through a deliberate step instead of slipping in informally through a chat message that gets forgotten by the next phase. A genuine new requirement discovered partway through gets scoped and confirmed the same way the original brief was, with a clear understanding of how it affects timeline, before it's built. The problem isn't change itself; it's unconfirmed change that nobody agreed to in writing.
Why This Protects Both Sides
This matters as much for you as for the developer. Without a clear change process, scope quietly expands until the original timeline and budget no longer make sense, and the disagreement usually surfaces at the worst possible moment — right before launch. A documented change step prevents that by making cost and timeline impact visible immediately, not discovered after the fact.
How Communication Works Between Phases
Each phase transition is a natural checkpoint — design approval, staging review, QA sign-off — rather than a single black-box period between kickoff and reveal. You see the staging site as it develops, not only the finished result, which means you can flag a concern while it's still cheap to address rather than after the build is fully committed to a direction.
Why This Structure Matters More Than the Timeline
The five phases aren't really about speed — they're about removing surprises. Every project follows the same sequence regardless of size, which means you know what's happening at every point, instead of waiting for a final reveal and hoping it matches what you asked for. That predictability is worth more than a slightly faster but opaque process, especially the first time you work with a given developer, and it's the clearest way to evaluate whether a process is real or just a sales pitch before you commit to a project.
Frequently Asked Questions
What do I need to provide to start Phase 1?
A complete brief: your goals, target audience, page content and copy, images, a reference site or Figma file if you have one, your sitemap, and target keywords per page.
How many design revisions am I allowed in Phase 2?
There's no fixed cap — revisions continue until the design is approved, since catching design issues before development starts is far cheaper than fixing them afterward.
Is SEO handled during development or after launch?
During development, in Phase 3. Schema markup, URL structure, and image optimization are built in as the site is constructed, not retrofitted once the site is live.
What gets tested during the QA phase?
Cross-browser compatibility (Chrome, Firefox, Safari), responsiveness across desktop, tablet, and mobile, accessibility against W3C guidelines, and performance against Core Web Vitals benchmarks.
Do I own my website fully after launch?
Yes — full credentials, hosting access, and documentation are handed over at launch, with no ongoing dependency on the developer for basic changes.
How long does the full 5-phase process typically take?
It varies by project size and complexity, but a complete brief at the start is the biggest factor in how quickly the later phases move — see how that plays out on a compressed timeline in the related post on fast website delivery.

