The software development process for UK SMEs has six phases: discovery, design, build, test, deploy, and support. Each phase has clear deliverables and review points, and you should see working progress weekly. The process is not a black box where you hand over requirements and wait months for a result. It is a collaborative effort where you are involved at key points and informed throughout. Understanding the process helps you work effectively with your development partner and get the best result.
This guide explains each phase and what to expect. See our process page for how we specifically approach software delivery.
What Happens in the Discovery Phase?
Discovery is the first and most important phase. This is where requirements are understood, scope is defined, and the project is planned. A good discovery phase prevents most project failures.
What happens:
- Requirements gathering: We talk to you and your team about what the software needs to do, who will use it, and what problems it solves.
- Current process mapping: We document how things work now, so the new software can improve on it rather than replicate its flaws.
- Integration assessment: We identify what systems the software needs to connect to and assess the technical feasibility.
- Scope definition: We agree on what is included in the project and what is not. This becomes the specification.
- Timeline and cost estimation: Based on the scope, we provide a fixed-scope quote and delivery timeline.
Duration: 1 to 2 weeks. Your involvement: 4 to 8 hours, spread across meetings and document review.
What Happens in the Design Phase?
Design translates requirements into a concrete plan for the software: database structure, user interface, and technical architecture.
What happens:
- Database design: Defining the data model, tables, relationships, and indexes. This is the foundation of the software.
- User interface design: Wireframes showing the layout of each screen. Not pixel-perfect designs, but enough to understand the user flow.
- Technical architecture: Choosing the technology stack, defining the hosting setup, and planning integrations.
- Review and approval: You review the design and approve it before development starts. Changes after this point are more expensive.
Duration: 1 to 2 weeks. Your involvement: 2 to 4 hours for review and approval.
What Happens in the Build Phase?
The build phase is where most of the development happens. Software is built in iterations, with working features delivered regularly.
What happens:
- Core development: Building the database, API, and user interface for the core features. This is the minimum viable software your team can start using.
- Iterative delivery: Features are built in priority order, with working software available for review every one to two weeks.
- Weekly progress updates: You receive a report of what was done, what is in progress, and what is next.
- Regular demos: Every two to three weeks, a live demonstration of the current state. You see real progress.
- Feedback incorporation: Your feedback from demos is incorporated into the next iteration. This is how the software evolves to match your needs.
Duration: 4 to 8 weeks for core build. Your involvement: 1 to 2 hours per week for progress reviews and demos.
What Happens in the Test Phase?
Testing ensures the software works correctly before launch. A good development partner tests throughout the build, with a dedicated testing phase before deployment.
What happens:
- Automated testing: Code-level tests that verify individual functions work correctly. These run automatically on every code change.
- Manual QA: A tester uses the software as a user would, trying every feature and edge case.
- User acceptance testing (UAT): You and your team test the software with real scenarios and data. This is where you validate that the software meets your needs.
- Bug fixing: Issues found during testing are fixed before launch. Nothing goes live with known bugs.
- Performance testing: The software is tested under expected load to ensure it performs adequately.
Duration: 1 to 2 weeks. Your involvement: 4 to 8 hours for user acceptance testing.
What Happens in the Deploy Phase?
Deployment is the transition from development to live use. This includes data migration, user training, and go-live.
What happens:
- Data migration: Existing data is exported from old systems, cleaned, mapped, and imported into the new software.
- User training: Your team is trained on how to use the new software. Training covers daily tasks, not every feature.
- Go-live: The software is deployed to production. Users switch from old systems to the new one.
- Post-launch monitoring: The development team monitors the software for any issues in the first days and weeks.
- Parallel running: If replacing an existing system, both old and new run in parallel for a period to catch any issues.
Duration: 1 to 2 weeks. Your involvement: Coordinating training and go-live timing with your team.
What Happens in the Support Phase?
Software is not finished at launch. The support phase covers maintenance, updates, and new features.
What happens:
- Warranty period: Free bug fixes for a defined period after launch, typically 30 to 90 days.
- Maintenance agreement: Ongoing maintenance covering security updates, dependency upgrades, and minor fixes. Typically 15 to 20 percent of build cost annually.
- Monitoring: The software is monitored for uptime, performance, and errors.
- Feature development: New features are scoped and built as separate phases, based on user feedback and evolving business needs.
- Support response: A defined response time for critical issues, typically 24 hours.
Duration: Ongoing. Your involvement: Reporting issues, prioritising new features, and quarterly reviews.
How Do You Work Effectively with a Development Partner?
To get the best result from the development process:
- Be available: Respond to questions within 48 hours. Delays in feedback delay the project.
- Appoint a decision-maker: One person who can make scope and design decisions. Multiple decision-makers slow everything down.
- Test with real users: During UAT, have the people who will actually use the software test it. They find issues that managers miss.
- Prioritise ruthlessly: Not every feature is equally important. Be willing to defer lower-priority features to keep the timeline on track.
- Use change requests: When you want to add something, use the change request process. This makes the impact on timeline and cost explicit.
- Trust the process: If you have chosen a good partner, trust their process. Micromanaging the development slows it down.
See our guides on choosing a development partner and development timelines for more detail. Ready to start? Book a free discovery call.