In this article, we describe the three main phases that a custom software project goes through, and the typical duration of each step. No two projects are alike or take the same amount of time to build. However, in our experience around 80% of the projects we work on fall into the ranges discussed below. If you are considering a custom software project and need a better understanding of how long it takes, keep reading!
Building Software is like Building a House
When planning and estimating a project, we consider each of the following phases separately:
- Requirements & Design
- Planning, Architecture & Development
- Software Testing
If you are familiar with building a custom home, the process for software is very similar, and it is an analogy I use often. The Requirements & Design phase equates to deciding on the type of house you want and then having an architect draw the blueprints for your home. At the end of this phase, you will have a concrete plan for your software application and all architecturally significant and budgetary impactful decisions should be made so that you can start the implementation with little to no surprises later on.
Planning, Architecture & Development is the same as scheduling the contractors, pouring the foundation and constructing the house. In the case of software, a project manager schedules creative designers, technical architects, software engineers, etc. The architects design the software foundation and framework, the creative designers create the user experience, and the software engineers make all the logic work. At the end of this phase, the application is fully built and you have got to use it yourself.
Just like a house, before you can move in, you need to make sure the application meets certain standards. You can think of the last phase of the project, Software Testing, like the inspections, walk-throughs, and punch-out of a house.
Requirements & Design – 2-4 weeks
In software development, the Requirements & Design phase is predictable and short. As the decision maker and primary stakeholder, you will work with your chosen IT team to:
- Document the system requirements (the things that the software must accomplish)
- Collaborate on different ideas and application features that will work together to meet your system requirements
- Discuss your users, their capabilities, and the desired look and feel for the application
- Document and review the application design (your application blueprint) and discuss any last minute changes
- Decide on the initial scope of the project (what are the features you are building in the first release vs. later releases)
We typically see that a Requirements & Design phase takes 2-4 weeks. The duration depends largely on the availability of you and your team, responsiveness to design reviews and questions, and how long it takes to make critical decisions.
Planning, Architecture & Development: 3-6 Months
Planning is the activity of laying out all the tasks in order, assigning the resources, and seeing which tasks can be done at the same time and which can’t. For example, you can’t put the roof on until the framing is done, and you can’t hang the drywall until the plumbing and electricity are finished. Planning is a short activity performed prior to development work and typically lasts 2-3 days.
Once planning is done, the system needs a framework or structure to build on. The technical architecture defines which technologies will be used and how they will work together. Like planning, the technical architecture tends to be straightforward unless the project involves complex system integrations or incorporates complicated or unusual technologies. The architecture of a system takes anywhere between one to two weeks to develop depending on the size of the system and the complexity.
The largest amount of time in software development is spent coding the application. Once the system is designed and the technical foundation is decided, we typically see the application built in 3-6 months.
If the timeline needs to be accelerated, this is the most common phase in the project to do so. With multiple tasks to be accomplished, additional development resources can be added to speed up the effort. At a certain point however, the additional resources will actually cause a decrease in efficiency due to additional coordination and planning needed, not to mention stepping on each other’s toes.
Testing: 3-6 weeks
Depending on your project, there is a variety of testing that could and should be used. All projects should undergo end-to-end testing and user acceptance testing. End to end testing is using all the features and functions of a system as a user would. During development, features are tested in isolation but not as a unified whole. Once all of the software is developed, an end-to-end test exercises the system holistically and allows the tester to compare what was built to the original specifications and any changes in design made along the way.
A user acceptance test (UAT) is a period of time where you, the stakeholder, use the system and sign off on the development. You can consider it like a final walkthrough of a custom home. Your job is to look at everything, identify any issues that the testers may have missed and start to get ready for production.
There are additional types of testing that you can elect to have done such as cross-browser or cross-mobile-device testing, load testing, performance testing and integration testing. If your application will be used on multiple browsers or mobile devices, you can choose to test on several different browsers/devices to ensure your application looks and works well on all browsers/devices that your user might choose.
If your application will have many users on the system at the same time, or will process a lot of data and must respond to the users within a certain time frame, load and performance testing should be considered. Load and performance testing makes sure that your application can handle heavy loads and identifies the slowest areas of your application for improvement, respectively.
If your application will interact with third-party systems, integration testing should be considered. Integration testing sends both expected and unexpected data through the connection of two systems to make sure they handle all the known and unexpected permutations of data and situations (a timeout, a corrupted file, an invalid value, etc.) gracefully.
Depending on the size of your application and the extent of the testing needed, we see most testing efforts taking between 3-6 weeks.
On average, we see software projects taking between 4-9 months to design and develop. The size and complexity of the project are the biggest factors in overall duration. A project is considered large or has a greater complexity if any of the following apply:
- Involves 25+ screens
- Includes an administrative portal as well as a user application
- Supports multiple platforms (web, tablet, phone, iOS, Android, Windows Phone)
- Integrates with multiple systems (security systems, payment gateways, CRM systems, ERP systems, HR systems, etc.)
- Involves data migration from an older system
- Has complex business logic
- Has complex reporting requirements
- Involves a data warehouse or data mart
The following are a few other factors that can impact a project timeline. Part of the job of a Project Manager is to monitor these types of risk so they can be identified early and mitigated to keep the project on track.
- Change of requirements or design after the project has started
- Delays when working with third-parties such as not receiving technical documentation, credentials to test systems or support on technical questions
- Missing requirements or unclear system design
- Inconsistent direction from multiple stakeholders
- Working with new technologies
- Fixing bad data or missing data in a data migration
The Checklist For Sharing Your Software Vision
Before you get started in developing your software app, your thoughts and ideas should be clarified and written down so they can be consistently and easily shared and understood. To help you get started on the right foot, we have created a checklist.