Skip to content
DT Nova

Software development steps: the seven stages from idea to running system

The software development steps are the same for a small internal tool and a large platform: discovery, requirements, design, building, testing, release and maintenance. If you are asking how software development works, these steps are the answer in its plainest form. This guide explains what happens in each of the steps in software development, what each one should produce, the decisions it settles and the mistakes that make projects late or expensive.

The short version

  1. Discovery: the problem, the users and whether software is the answer.
  2. Requirements: what the system must do, written down and agreed.
  3. Design and architecture: how it looks, how it is built and what it connects to.
  4. Building: the code, in short rounds you can see working.
  5. Testing: proof that it does what was agreed, safely.
  6. Release: the move into real use, including data and people.
  7. Maintenance: keeping it secure, supported and useful for years.

The steps at a glance

StepMain questionWhat it produces
1. DiscoveryWhat problem are we solving, and for whom?Goal, users, current process, constraints, buy or build decision
2. RequirementsWhat must the system do?User stories or requirements, priorities, what is out of scope, fixed scope for the first version
3. Design and architectureHow will it work and how is it built?Screen designs, data model, technology choice, integration plan, security and hosting plan
4. BuildingDoes each part work?Working software in a test environment, code in your repository
5. TestingDoes it do what was agreed, safely?Automated tests, acceptance results, fixed defects, security checks
6. ReleaseCan people use it for real?Production system, migrated data, trained users, monitoring
7. MaintenanceDoes it stay secure and useful?Updates, fixes, upgrades and improvements on a plan

Step 1: Discovery

Discovery answers whether to build anything at all. It looks at the business goal, the people who will use the system, how the work is done today and what the current tools cannot do. It also checks the alternatives: an existing product, a configuration of a system you already own, or a small integration may solve the problem for less. A good discovery ends with a short written statement of the goal, the users, the constraints such as budget, deadlines and regulation, and a recommendation. When we run discovery, the recommendation is sometimes not to build, and we say so; see software consulting.

Step 2: Requirements

Requirements turn the goal into a list of what the system must do, usually as user stories ("as a dispatcher, I want to move a job to another technician so that...") with acceptance criteria that say how to check each one. Equally important is the list of what the first version will not do. Non-functional requirements belong here too: how many users, how fast, which devices, accessibility, data protection, hosting location and how long data is kept. The requirements are the basis of the scope and price, so they should be written plainly enough for the business owner to approve them line by line.

Step 3: Design and architecture

Design has two halves. User experience design decides the screens and flows, often first as clickable prototypes tested with a few real users. Technical design decides the architecture: the data model, the technologies, how the system connects to others, where it is hosted, how users sign in and how data is protected. Choices made here are expensive to change later, so they are written down with the reasons. For the technology layer, see software development technologies; for the connections, API integration.

For the patterns, diagrams and documentation this step produces, see our software architecture guide.

Step 4: Building

Building is where most of the hours go. Modern teams build in short rounds, typically one or two weeks, each ending with working software in a test environment the client can use. Code is reviewed by a second engineer, kept in version control from the first day and, at DT Nova, in the client's own repository. Small, frequent deliveries make progress visible and let the business change priorities without throwing away work. How the rounds are organised depends on the method chosen; our guide to software development methodologies compares waterfall, iterative, agile and DevOps approaches.

Step 5: Testing

Testing is not a phase that starts when building ends. Automated tests are written alongside the code and run on every change; integration tests check the connections to other systems; acceptance testing lets the business confirm each requirement against its criteria; and security checks look at dependencies, permissions and data handling. Before release, the system is tested with realistic data volumes and on the devices and browsers your users have. Where an outside team is useful, see software testing outsourcing.

Step 6: Release

Release is more than switching on a server. Data is moved from the old system and checked; users are trained and given short instructions; monitoring, logs, backups and alerts are in place before the first real user arrives; and there is a plan for going back if something fails. Larger systems are often released in stages: one team, site or customer group first, then the rest. Mobile apps add store review to this step, which our guide to the mobile app development process covers.

Step 7: Maintenance

A system that is used for years spends most of its life in this step. Maintenance covers security updates to the components it uses, upgrades before the languages, frameworks and databases it runs on go out of support, fixes for defects found in use, and improvements as the business changes. It should be planned and budgeted from the start, with an agreed response time for problems and dates for the planned upgrades. In the EU, the Cyber Resilience Act, Regulation (EU) 2024/2847, adds obligations on handling vulnerabilities for many products with digital elements, which makes a maintained list of components part of normal maintenance.

Our technical debt guide explains what happens when this step is skipped.

Common mistakes at each step

  • Skipping discovery and building a solution to the wrong problem.
  • Requirements nobody signed, so every change becomes a dispute.
  • Architecture by habit instead of by need, leaving a system that is hard to host or hand over.
  • Long build phases with nothing to see, so problems surface months late.
  • Testing left to the end, when fixing a defect costs the most.
  • Release without a way back or without trained users.
  • No maintenance budget, so the system ages until it is unsafe.
  • Code and accounts in the supplier's name, which ties the client to one company.

How the steps change with the method

In a waterfall project, each step is finished and approved before the next starts, which suits fixed, well-understood requirements and regulated work that needs formal documents at each gate. In agile work, steps 2 to 6 repeat in each round for a small slice of the system, which suits projects where needs become clear as people use the software. Most business projects today mix the two: discovery, requirements for the first version and the main architecture up front, then building, testing and release in short rounds. Whatever the method, every step still happens; the method only decides how often.

How DT Nova runs the steps

Our projects start with a short discovery and a written scope with a fixed price for the first version. We design the main flows and the architecture, then build in two-week rounds with a working test environment the client can use after each one, automated tests on every change and the code in the client's repository from the first commit. Release includes data migration, monitoring and training, and maintenance is agreed in writing before launch. Hosting is in an EU region as standard. See custom software development for the service, and our guide on how to choose a software development partner for questions to ask any supplier.

Questions people ask

What are the main steps in software development?

Seven steps cover almost every project: discovery, requirements, design and architecture, building, testing, release and maintenance. Together they are often called the software development life cycle. Methods differ in how they order and repeat the steps, but none of them skips one without paying for it later.

Do the steps always happen in order?

Not strictly. In a waterfall project each step is finished before the next starts. In agile work the steps repeat in short cycles: a slice of the system is specified, built, tested and released, then the next slice follows. Discovery and maintenance bracket the cycles either way.

Which step is most often skipped?

Discovery and written requirements. Teams want to start building, and the questions that were never asked return as rework during testing or after launch. A few days spent agreeing what the system must do, for whom and what is left out is the cheapest work in the whole project.

How long does each step take?

It depends on the size of the system. As a pattern, discovery and requirements take days to a few weeks, design overlaps with the first building rounds, building and testing take most of the calendar, and release is days. Maintenance lasts as long as the system is used, which is usually years.

What should we receive at the end of a software project?

Working software in production, the source code in your own repository, the cloud and service accounts in your company's name, documentation that lets another team continue, a list of components and their licences, the test suite, and a maintenance plan with dates for planned upgrades.