Uploaded by Sinisa Nenkov

A Realistic Timeline For Building Custom Software

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 building a custom software project and need a better
understanding of how long it takes, keep reading!
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.
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 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 of 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.
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
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
If you’re ready to share your software ideas, tell us! We’ve been creating realistic software timelines for nearly 20 years, and we’d
love to work with you on yours.