You have three proposals for a custom website. All three mention analysis, design, development and handover. None of them says what exactly you will receive at each stage. The steps in a custom website design process only become comparable when each one has a defined deliverable, a named owner and a clear condition for sign-off. This guide helps you track progress yourself, instead of assuming every project should hit the same fixed deadline regardless of what it needs.
What are the stages of a custom website design process, from discovery to handover?
A custom website design process starts with clarifying the goal, uncovering requirements and setting the scope of the first version. Next come user flow design and an interactive prototype, then development, content and data preparation, acceptance testing, launch, and the handover of documentation and access. Before you move past any stage, you need a named owner, a deliverable you can actually review and a sign-off condition. Seeing a few finished pages, on its own, does not mean the project is done.
By custom design, we mean a site built around your business's specific processes. Your business should not have to bend to fit the site. That is why a large share of the work happens before anyone decides how the site looks. First, the team has to understand how things get done today.
The order of the stages reflects how decisions depend on each other. Until the first-version scope is approved, the designer lays out the user flow based on guesswork. Until that flow is clear, the technical team builds things it will probably have to rebuild.
Not everything runs in strict sequence, though. Content preparation and test scenarios can move forward alongside development. They should. Waiting for coding to finish does not remove these tasks from the plan. It only pushes them later.
What problem and goal need to be clear before you commission the site?
Start by writing down the outcome you expect from the site, not its list of pages. “Home, Services, About, Contact” tells a vendor nothing about your problem. From a list like that, they can only estimate the visuals. They still don't know what the site is supposed to fix.
Imagine a service company frustrated by incomplete customer requests. Every day, staff call customers back to get a photo of the device or a contract number. This company needs a step-by-step form and a clear process for reviewing requests. A fresh look might be nice, but it won't solve the problem. We'll follow this hypothetical example through the rest of the guide.
Write your goal using this short template:
Primary audience: Who uses the site the most?
Current problem: What takes too long today, gets lost or arrives incomplete?
Desired action: What exactly should the user do?
Sign of success: How will you know the project worked? For example, fewer follow-up calls.
Constraints: Budget, legal requirements, existing systems and busy seasons.
Name one person as the final decision-maker and one as the representative of internal users. In a kickoff meeting, the first question I usually ask is: if sales and support disagree, who has the final say? Consolidate feedback from all departments before it goes to the vendor. Otherwise the delivery team gets stuck between two contradictory requests.
This guide doesn't cover the general basics of ordering a website. It shows you what deliverable to expect at each stage of a custom website design process and how to decide whether to approve it.
Discovering requirements and writing an approvable scope of work
The scope of work is the agreed list of features, how each one behaves and what is explicitly left out of the project. Take the “out of scope” section seriously. Many disputes start with expectations nobody wrote down.
For each feature, record five things: the user role, the input, the expected result, the error case and any external dependency. In the service request example, a few simple questions make the scope clear. Who sees a new request? Who changes its status from “under review” to “done”? What message does the customer get each time the status changes?
The table below lists each stage of the custom website design process with its owner, deliverable and sign-off condition. I suggest using this table to steer the project: in every meeting, state which deliverable is ready for review.
Stage | Owner | Deliverable | Sign-off condition |
|---|---|---|---|
Goal and problem | Client, with the vendor's help | One-page goal document | Approval by the final decision-maker |
Requirements discovery | Vendor | Feature list with role, input, result and error case | Review by the user representative |
First-version scope | Vendor and client | In-scope and out-of-scope list, with assumptions | Written approval from the decision-maker |
User flow and interactive prototype | Designer | Clickable prototype and list of behaviors | Approval scenario run on mobile |
Development | Technical team | Testable version in an environment separate from the live site | Scenario demonstrated with sample data |
Content and data | Client | Final content and cleaned data | Sample checked in the test environment |
Acceptance testing | Client representative, supported by the vendor | Test report and defect list | Acceptance criteria passed |
Launch | Vendor | Launch plan and rollback plan | Post-launch test passed |
Handover | Vendor | Code, design, documentation and access | Signed handover record |
Don't confuse the person who does the work with the person who approves it. The designer builds the prototype, and your representative approves it. If one person both builds and approves, you have no independent check.
Don't hide unknowns either. Say you still don't know whether your current inventory system can be connected. Add that uncertainty to the assumptions list, assign someone to investigate it and set a deadline for the decision.
Legal terms, such as payment terms and ownership, belong in a separate document. For that, see our guide to writing a website design contract.
Separating first-version features from later development
My rule for the first version is simple. A feature stays in only if leaving it out would break the user's main path or leave an operational or security requirement unmet. This split is the most consequential decision in the custom website design process, because it sets the size of every stage that follows.
In the service example, submitting a request and viewing its status are essential. Without them, the project misses its goal. A flexible report builder can wait for the next version. For the first few months, a manager can manage with a simple table export.
Dropping a feature is not the same as simplifying it. You might enter older customer records by hand at first and postpone automatic migration. That is a sensible call, but it has a cost: someone has to spend time on it every week, and the risk of errors goes up.
So record everything left out of the first version, along with the reason and the dependency:
Left out of the first version | Reason | Dependency |
|---|---|---|
Flexible report builder | The main path works without it | Several months of real data to design the reports |
Automatic connection to the inventory system | It's still unclear whether a connection is possible | Answer from the system's supplier |
SMS for every status change | Messages at submission and completion are enough for now | SMS service contract |
This list prevents a common dispute. Months later, nobody can call the missing report builder a delivery defect, because you recorded why it was left out.
Approving the first version doesn't lock your requirements forever. Businesses change, and the site has to change with them. Just weigh the impact of each new request on the process before anyone starts on it.
Designing the user flow and approving the interactive prototype
A user flow is the sequence of steps a user takes to reach a goal. A prototype is a clickable model of that flow, built by the designer before any coding starts. It lets you try the sequence before the site exists.
Approve the page structure and the main flow first. Colors and visual details come after. If you reverse that order, the designer produces final designs for pages that may later be removed or merged. In a custom website design process, that kind of rework gets expensive.
The prototype shouldn't only show the happy path, because users don't always fill in forms correctly or completely. Ask to see these states too:
Empty state: What does a customer who hasn't submitted a request yet see on the tracking page?
Form error: If the contract number is wrong, where does the error message appear, and how is it worded?
Waiting for a response: What does the user see while a photo uploads or the form is being submitted?
Role differences: What can the operator and the manager each see and do?
For approval, ask your representative to play the customer. They should open the prototype at mobile screen size and take a request all the way to the final confirmation message. Note every spot where they hesitate or ask “where do I tap now?”
This stage produces the editable design file, reusable components such as buttons and form fields, and a list of approved behaviors. A prototype is still not a working product. Approving it means you accept the proposed flow and behavior. It does not mean the team has built half the site.
Measure progress by results you can test, not by pages that merely look good.
Development plan, progress demos and managing change
Development is usually the longest part of the custom website design process. Plan it around features that can be demonstrated, not vague percentages. “Most of the work is done” gives you nothing to check. “Request submission and status view are ready” is something you can verify the same day with a test request.
A staging environment is a copy of the site, separate from the public one, that only your team and the vendor can access. Run every progress demo there, against a specific scenario. Don't accept demos on a developer's laptop.
At the end of each demo, ask for three things in writing: what can be tested, what is incomplete and which decisions the team needs from you. This short note brings hidden delays to light early. It might show, for example, that the team is waiting on your decision rather than writing code.
Use a standard form for change requests so their impact on the process stays traceable:
Form section | What to write |
|---|---|
Request description | What exactly is the new behavior? |
Reason | What problem does it solve, and for whom? |
Impact on scope and tests | Which features and acceptance criteria change? |
Impact on time and cost | The vendor's estimate, with its assumptions |
Approver's decision | Approve, reject or move to the next version, with a name and date |
The key boundary at this stage is between a defect and a change. If a feature doesn't meet the agreed criterion, that is a defect, and fixing it is usually part of the vendor's original commitment. If you want new behavior, such as one request covering several branches, that is a change request.
Investigate unknown integrations early. If the site has to connect to an inventory system or an SMS service, the technical team should first build a small technical proof of concept. It shows whether the connection is feasible long before the final weeks.
Preparing content, data and the required access
Split the materials needed to commission a custom website into two groups: inputs for kickoff and inputs for launch. The vendor doesn't need every access on day one, and granting it early only increases security risk. Late inputs, though, are one of the most common reasons schedules slip in a custom website design process.
Input | When it's needed | Practical note |
|---|---|---|
Description of the current process | Kickoff | A simple diagram on paper is enough. |
Sample forms and messages | Kickoff | The versions you actually use today. |
Visual identity | Kickoff | Logo, colors and fonts in editable formats. |
Sample content | Kickoff | A few real texts to test the design against. |
User roles | Kickoff | Who can see and change what. |
Integration documentation | Kickoff | Technical guides for external systems, or a way to reach their support. |
Final content | Launch | Edited and approved by the content owner. |
Cleaned data | Launch | No duplicate records, with columns mapped. |
Domain and hosting details | Launch | Limited, temporary access, not the main account password. |
SMS or payment settings | Launch, if needed | The account should be in your business's name. |
For each input, settle four things: owner, file format, deadline and approval method. “Marketing will provide the content” isn't enough, because it assigns the task to a department instead of an accountable person. You need one name and one date.
Data migration means moving old information into the new system, which involves more than copying it. You have to map the columns, meaning you decide which field in the new system receives the “Phone” column from the old file. Resolve duplicate records as well, and test the migration on a small sample first.
Use dummy or anonymized data for testing, not real customer information. Keep access limited and temporary. Never store passwords in a shared content file, and ask for a separate, secure channel to transfer them.
Don't leave content production until coding is finished. Real text is rarely the same length as placeholder text, and it sometimes changes how a form behaves. A legal requirement, for instance, might add a new consent checkbox to the form.
Testing features and approving acceptance criteria
Acceptance criteria are testable conditions that show a feature works as agreed. The vendor's technical testing is necessary, but it doesn't replace business acceptance. The technical team finds errors in the code. Your representative checks whether the site handles the real process correctly.
Here is how you might write the criteria for our hypothetical example. Put these statements in the test report so sign-off doesn't come down to personal impressions:
Type | Criterion |
|---|---|
Positive | Given the customer is logged in, when a valid form is submitted, a request is created with a unique ID and the same customer can see its status. |
Negative | If the customer submits the form again, no duplicate request is created. |
Negative | If another user edits the URL of the request page, they cannot see that request's information. |
The last criterion targets a common weakness in sites with user accounts: viewing other people's data by changing the page URL. For a fuller list of security tests, the OWASP Web Security Testing Guide is a reliable reference. Ask the vendor which parts of it their own testing covers.
Beyond the main path, acceptance testing should also cover:
Display and behavior on mobile and on the browsers you agreed on in advance
Each role having access only to what it should see
File uploads in allowed and disallowed sizes and formats
Clear error messages that an ordinary user can understand
An actual restore from backup, beyond confirming the backup file exists
Performance under agreed conditions, such as a specific number of simultaneous users
Accessibility means people with different abilities can use the site. Try putting the mouse aside and filling in the form with the keyboard alone. Then check that every field has a real label, so screen reader software can read it out. For more detailed criteria, see the W3C web accessibility guidance.
After testing, sort defects into two groups: launch blockers and those that can wait. For each one, record an owner, a status and test evidence, such as a screenshot or step-by-step instructions to reproduce the error. Final acceptance should come from your designated representative, not from the vendor.
Launch plan and training the team that will run the site
Launch and acceptance are different steps. A feature approved in staging still needs a plan to reach the public site. In a custom website design process, launch is the point where customers see mistakes directly. Before it, have these ready:
Restorable backup: You have actually tested restoring it at least once.
Person in charge: One named person, with a phone that gets answered on launch day.
Low-risk window: The time when you get the fewest visits and orders.
Post-launch test: A short list of main paths to run again on the public site.
Error-reporting path: Internal users know who to tell about a problem, and how.
If the new site replaces an old one, check three things separately. Redirect old URLs to the new pages so you keep your links and search rankings. Move any data submitted on the old site after the last migration into the new system. Tell everyone in advance when data entry on the old site will stop.
A rollback plan sets out how the team restores the previous version if something breaks badly after launch. The harder question is what happens to requests submitted during those few hours. Write that answer down before launch, not in the middle of a crisis.
Train people with real tasks. Have an operator take a request from submission to closure, and have a manager change an employee's access. Record the session or turn it into a short guide so new hires can use it later.
Treat defect fixing, maintenance and new development as separate things. Defect fixing means correcting behavior that doesn't match the agreement, within a set period after launch. Maintenance covers updates, backups and ongoing monitoring. Development is any feature that wasn't in the original scope. Put the limits of each in writing before launch, because each comes with different commitments.
Handing over code, design, documentation and access
A proper handover gives you a package you can use to run the site and keep developing it, even with a different team. A zip file sent over a messaging app doesn't count. The code should live in a repository, which stores the code together with its full history of changes. This is the last step in the custom website design process, but mistakes here can cost you months later.
Print this checklist and fill in the evidence, owner and status for every row:
Handover item | Evidence | Owner | Status |
|---|---|---|---|
Agreed code with version history | Owner access to the repository | Vendor | Open / Closed |
Editable design file and reusable components | Files transferred to the client's account | Vendor | Open / Closed |
Data structure | Document explaining the tables and how they relate | Vendor | Open / Closed |
Installation and deployment guide | Successful setup in a separate environment | Vendor and the client's technical person | Open / Closed |
Required configuration, without exposing passwords | List of settings and the secure location where passwords are stored | Vendor | Open / Closed |
List of dependencies and licenses | Names of the libraries and off-the-shelf tools used, with each one's license | Vendor | Open / Closed |
Ownership of domain, hosting and repository | Accounts in your business's name | Client | Open / Closed |
Access to external services such as SMS and payment | Access level of each account | Client | Open / Closed |
Removal or review of temporary access | List of revoked access | Client and vendor | Open / Closed |
Check account ownership with extra care. The domain, hosting, repository and external services should all be in your business's name, and the vendor should hold only limited access. This is also when you remove or review the temporary access granted during development.
I recommend a practical test. Ask a technical person who wasn't on the project to set up the site in a separate environment using only the documentation. If they need to call the vendor at every step, the documentation is incomplete. Your own team should also be able to handle day-to-day tasks without help.
A real handover means the work can continue without the builder in the room.
To close the handover record, list the version number, the date, the documents delivered, the tests passed and any open items. Every open item needs someone to follow it up and a deadline. Otherwise it becomes a task nobody owns once the handover is done.
What factors change the project timeline?
Three things determine how long a project takes: scope, dependencies and team capacity. So the short answer to “how long does custom website design take?” is this: until those three are clear, you have no deadline you can rely on. Any number given before that is a guess.
It helps to split the time in a custom website design process into three parts: doing the work, waiting for approvals and inputs, and investigating risks. I suggest writing the second part into the plan as its own item, because it's easy to forget. If the team waits a week for a signature, that week is part of the project too, even though nobody is writing code.
These are the main factors that move the timeline:
The number of workflows, since each one has its own statuses, roles and messages
How complex the roles and access levels are
Integrations with external systems, especially poorly documented ones
The quality of legacy data and how much cleanup it needs
How ready the content is
Changes made after a stage has been approved
A good schedule states its assumptions clearly. In our hypothetical example, the plan depends on three things: approvals from a single representative, sample data ready on time and the ability to test integrations. If any of these falls through, the plan has to change too.
Some work can genuinely run in parallel, such as producing content while development is underway. Starting development on an unclear flow, or migrating data without an approved sample, won't speed anything up. It only makes rework more likely.
That's why you should ask the vendor for a plan with a built-in way to re-estimate. If your input arrives late or the scope changes, how will they update the plan? For a broader view, read the factors that affect how long website design takes.
نمونهکارهای ما در همین زمینه
From idea to
Bespoke projects run in stages: each stage produces something usable, and is reviewed and settled before the next one starts.
Choosing a vendor and requesting proposals based on a shared scope
When you commission a custom website, send the same package to every vendor. Only with identical inputs can you make sense of the differences in price, timeline and stages between proposals. Your package should include:
The goal and the current problem
Users and roles
First-version features
Out-of-scope items
Integrations with other systems
The state of your content and data
The main acceptance criteria
Any time constraint, with the reason behind it
In return, the vendor should spell out their assumptions, the deliverables for each stage, your responsibilities, how they will report progress, what they will hand over and what services they offer after launch. A proposal that shows only a total price and a page count gives you nothing to compare.
Don't judge a portfolio on looks alone. Ask whether they have built something with a similar workflow or integration, and what turned out harder than expected. You'll find a fuller list in key questions to ask web design companies.
If you'd like to go through your project's scope with us, Niasa's custom website design services start from exactly this point. We define the goal and the first version together and write down the assumptions. You don't need a finished requirements document to start the conversation. A description of your current process and a few real forms are enough.
Your steps for this week:
Fill in the goal template on a single page.
Name your final decision-maker and your internal user representative.
Write your request package and send it to several vendors.
Compare the responses against the stage table above.
هدف سایت و نیازهای نسخه اول را برای نیاسا بفرستید تا گفتوگو درباره مسیر اجرا و پیشنهاد متناسب با پروژه شما شروع شود.
Frequently asked
5How long does custom website design take?
Project length depends on the number of workflows and the complexity of integrations, not just the page count. Ask the vendor for an estimate that states its assumptions about content, approvals and access, and ask them to revise it once requirements discovery is finished.
What documents do we need to commission a custom website?
To get started, you only need a description of your current process, sample forms, user roles and a list of the systems the site must connect to. That is enough for a focused conversation. Final content and production access can follow on schedule, with limited permissions.
Can we change features after the design is approved?
Yes, but changing one page can also affect data, user access and tests. Before any work starts, the impact on scope, time and cost should be clear, and the decision should be recorded.
What should we receive when a custom website is handed over?
Besides a working version of the site, you should receive the agreed code and design files, a setup guide, account details and test reports. A good benchmark is whether you can run the site and keep developing it without depending on one person's verbal explanations.
Does launching the site end the vendor's responsibility?
Launch only marks the start of public use. It does not define what the vendor is responsible for afterwards. Defect fixing, maintenance and new features should be treated separately, and the project agreement should define the scope of each.









