The IT industry is growing and changing rapidly, but the market is packed with similar products. If a product is regular, users turn away from it and look for more progressive alternatives. That's why it's a matter of survival for product owners to find the balance between launching a new product as fast as possible and not missing the relevance of the new idea during all stages of its implementation. So here I am going to talk about software development time.
How to estimate the right software development timing? As a Delivery Manager at Mad Devs, I often work on eliciting project requirements and preparing estimates before a project starts. This article reflects on my humble experience and aims to provide straightforward answers. The answers can help clients looking for a reliable contractor understand how development timing is shaped.
So timing is an incredibly important indicator because it affects the final cost of development, the feasibility of research results, and the actuality of the future product in the market. To calculate the time for development, there is the Time-to-market metric, which shows the time from concept to the final launch. And I will tell which key elements it implies for developing a whole new product.
Client's concerns
From the beginning, let me notice that the time it takes to develop a solution varies!
But before we begin to work, we face the common questions that our clients often ask:
- The analog project is so simple. Is it so difficult just to copy it?
- How come MVP development takes ~6+ months?
- We use multiple integrations in the project. Doesn't it save us time?
- I've got three completely different estimates from different vendors. How should I distinguish between them?
- What happens after the project is launched? How do I make changes after launching if necessary?
Your competitor's product might be very simple in use, but you can never assess how much has been done to develop it. Consider these questions: Did they develop it from scratch or based on a ready-made solution? How big was the team? What was the functionality of the first release? How is the development process organized?
If we don't know the answers, we can't tell how big the scope was or how much time the development of a product took. But in answering these questions, we can identify the main factors that shape development timing.
In developing custom software, it is important to consider what the final product will do and how it will be used. Typically, custom software projects take 4-9 months from conception to completion of testing and release.
In order to guarantee a well-designed and durable software solution is sustainable and extensible, careful engineering is required. Here are some details about custom technology development and why it might take longer than you expected.
First, let's highlight the key factors of a software project's timing:
- Product development purpose
- The clarity in product requirements and vision
- Team composition
- Organizational process.
Importantly, these factors will affect not only the preliminary estimate but also the final timeline. So I'll cover each one in detail.
Let's make your idea come true
Before we divide the development process into steps, let's discuss the issues clients and developers face.
Development purpose
Before you start developing an application, you need to decide on the purpose of development. There is a big difference between developing a product to validate an idea and using a product as a stepping stone for a full-fledged business.
Idea validation
It's important to understand that if a product built like this succeeds, you'll most likely need to rewrite it from scratch. Poorly written systems with weak foundations are difficult to support in the long term. To save even more time and money on idea validation, try to look for existing systems that may fit the requirements fully or partially.
For example, pay attention to low code/no-code solutions in the kind of website builders and relatively recent application builders for mobile devices. They allow you to quickly release a prototype of a working app, which will show the degree of users' interest and help to get feedback from them. It will allow taking interviews or getting a customer journey map (CJM) that will show should you realize this idea. How to do it in the best way, and which specialists do you need? And if the idea is worth the investment of effort, time, and money, then you can safely hire a team of professionals.
In Mad Devs, we offer both of these things. We can analyze an idea in a variety of scenarios, assemble appropriate prototypes with minimal use of resources, and provide a variety of metrics indicating the real potential of the future product. Also, we provide end-to-end development and support of the product. As well as each of its stages separately.
A full-fledged business idea
If you are determined to create a product that will be competitive in the market, the development team will focus on building a stable and scalable system that will:
- Handle large numbers of users in the future
- Have an enterprise level of stability and security to initially avoid the possibility of critical bugs leading to a bad reputation among users and large financial losses.
- Be easily understandable by new team members so that the "bus factor" is ruled out and the risks of specialist replacement are minimized
- Be easily supported so that the development of new features doesn't require changing the entire architecture
Be well documented that anyone who needs to study the project can get all the data they need from one source in a clear way and help new specialists get up quickly and easily.
Why building a competitive product takes a long time
The development process involves more than actual software engineering. Apart from coding, development is about:
- Writing technical and business documentation and keeping it up-to-date
- Covering modules with automated tests to ensure that every deployment to production is safe
- Setting up CI/CD to save time on routine processes
- Management of a team and organization of communication between all members in product development, to distribute tasks so that they are all performed consistently and there is no downtime
- Possibly other processes depending on the specific characteristics of a project
These activities usually take 30-40% of development time. They fully pay off in 1.5-2 years. If a project lasts for more than 6 months, they bring value by saving time on regression testing and preventing several cycles of internal testing & feedback before releases. Also, properly established processes, attention to all important aspects, and high development culture, in general, attract developers at a much higher level, who don't just want to make good money, but feel like they're in the right place.
The clarity in product requirements details
At the beginning of a project, requirements are not yet clear (presented as a vague list of features or as an example to be copied) and design is absent. With unclear requirements, it is almost impossible to predict exactly how much time development will take.
Let's say we need to develop the simplest signup feature. Here are examples of questions we'll need to address to estimate the scope of work:
- What exact information does the user need to specify when signing up?
- Should all the data be on one screen or split into several ones?
- Do we need 2FA with signup confirmation by email or SMS code?
- Are we going to enable signup with social media like Google+ or Facebook?
- Should the user be automatically logged into the system after signup and will it be optional?
- Does the signup feature include inviting contacts to the app?
All these factors can significantly affect the development time. That's why quotes usually cover not only the functionality you requested but also the risks and time needed to change the scope.
When a team lacks clear requirements or time for deep research, the time estimate is very rough. To better understand the quote, ask your potential vendor to break down the time estimate into features to showcase the details. It will not only help you to define the accuracy level of features but also give you more information for smarter decision-making. It also affects the subsequent workflow. If features were not originally intended to be added, adding them quickly can lead to bugs, making the end goal harder to achieve, worsening the application's structure, causing more communication between developers, and discussing problems.
Team composition
The time estimate can vary significantly depending on team composition, which basically means:
- How many and what kind of specialists are included in the team?
- What are the experience level and background?
Everything is simple here. Depending on the stage of a project, adding more people to the team can speed up the development. Yet the marginal value is diminishing, so doubling the number of developers won't always increase the development speed two times.
An important thing here is how the tasks in the project are connected to each other. Let's say you need to develop a web application and a mobile one. You can hire different people and extend your team. Yet, if you need to develop a single module for an already existing system, team extension probably won't help. Also, keep in mind that the bigger the team, the harder it is to manage.
Additionally, the experience level and industry knowledge of team members are crucial. If a specialist has a specific background fitting the project, it will be easier for them to grasp the context of the development process, suggest optimal solutions, and highlight potential risks.
Two junior or even middle developers, in most cases, won't replace a senior one. Especially in high-load projects that require thorough preparation and architecture design & planning. Without the contribution of senior developers, it may turn out that your product is not sustainable at all.
How long does it take to develop an app
So, how long does it take? What will need to go through before the application goes to market? From start to finish, a project goes through a series of phases called the development life cycle of Agile methodology. Concept, inception, release, maintenance, and retirement are the general stages. According to the team's Agile methodology, the life cycle may differ slightly.
At Mad Devs, the development life cycle includes such steps:
- NDA signing stage
- Pre-discovery stage
- Discovery stage
- Iteration stage
- Development stage
- Design stage
- QA and testing stage - Deployment and release stage
- Maintenance
Our team aims to solve problems of any complexity by building transparent and well-functioning processes. We are looking for reliable solutions for complex tasks. Read more about software development processes at Mad Devs.
In our company, we adhere to agile software development methodology during the development process. It means that we divide the workflow into iterations, usually between two and four weeks long, with a final completion date. Each iteration will typically consist of planning requirements, developing a product, testing software, delivering iteration, and feedback.
NDA signing stage
- Time: depends on how long the parties will discuss an agreement
- What we are doing: NDA
In this phase, after both ensure that all parties have a common understanding, we sign an NDA (non-disclosure agreement). We use NDA to protect trade secrets and prevent confidential information theft.
Pre-discovery stage
First of all we discover the landscape to find out as much information as possible about the problem that needs to be solved, so after we could create a research plan. In this phase, we are talking about laying a solid foundation and preparing for future work.
Discovery stage
Custom development begin with the product's design. Creating a detailed plan, building the structure, defining the technological stack, and completing the project according to your product's specifications are essential.
A strong team is one of the most important points during the whole process. So it is important to have a structured team's roles. It will allow specialists to better perform their assigned tasks. The team roles during the discovery stage:
- Business analyst—collect and document requirements, analyze competitors' products, and detail the product vision
- Architect—develop goals, principles, and rules for the team, work on compiling a list of technical risks, and prepare a high-level description for the technical process
- UX designer—conduct UX research and analyze habits of the target audience
- Project manager—organize and manage the Discovery Stage
- Lead QA—draw up a test strategy
As a result of this phase, developers have a clear understanding of what should be built, what they should use, and how it should be built. It is important to determine the core features and the requirements of the users. Together with your development team, you'll establish the following:
- System requirements and/or core features
- A set of technologies that should be used
- End User definitions and their experience with the application
- Various interface and user requirements
- The initial scope of the project—what will be built in the first, second, third, etc. sprints
The requirements and design phase typically takes two to four weeks to complete. A lot depends on the availability of the client during this phase to answer questions and make decisions as the development team designs the plan. This phase must be thoroughly worked through to minimize surprises during the building and release phases.
Once the concept is outlined, the project manager will check the availability of their colleagues and select the best people for the project. Sometimes, the team needs specialists who must be searched for and hired separately for the project.
If the client needs the product to be built faster, then we can add additional developers to the team. But if the team grows too large, adding more developers will actually result in the project's timeline growing longer. Because managing a larger team will take more time.
Implementation stages
To keep engineering teams organized and on track, project managers are needed over this phase. Additionally, the team has crucial roles:
- Software developers are needed to write the code
- Technical architects for designing the framework
- Designers to help with user interface and/or user experience
- DevOps engineer brings together teams to increase the velocity of software development and release
Moreover, project managers may monitor risks such as:
- Requirement changes or scope creep after the project has started being built
- Timeline delays result from a lack of responsiveness from third parties, such as not providing critical documentation, credentials, etc
- Fuzzy scope line items, requirements, or system design items—these will make it harder for developers to build and will require additional time for clarification
- Too many cooks in the client kitchen, i.e., unclear direction from the stakeholders
- Bad data from an existing product or errors in data migration to the new product
During this phase, developers, UX designers, QA team will work together to create the product based on all product requirements. And development and testing process will repeat until the product is ready.
Development stage
As the bulk of the work is done here, it tends to be the longest phase. This phase involves writing the actual code of the system, developing and deploying the system's hardware, and preparing the primary test data.
Our developers follow coding guidelines and best practices to ensure that their software is secure, reliable, and portable. Thus they create an infrastructure in which it is convenient to work, for example:
- Break big tasks into smaller chunks
- Arrange communication channels with clients
- Implement CI/CD standard practice to automate software development and infrastructure-as-code delivery
- Test everything to detect and minimize bugs
- Use radiators to track business metrics and see whether a specific feature brings business value
- Use logging and alerting tools
Design stage
As mentioned above, designers, before starting the work, collect project requirements and do research work to know more about the target audience.
After UX designers create wireframes, a data flow diagram, technical innovation, and a user interface, the result make a prototype or a draft with an excellent visual representation of the product.
In order to turn the design into code, developers will work with UX designers. Developers use this stage to quickly create working software and make improvements to satisfy clients.
QA and testing stage
Over this phase, we usually test and compare the work results during iteration. We test the quality of the product using boilerplates to facilitate the QA and testing processes. Furthermore, the QA team test the product for its compliance with requirements. We suggest not missing this step to ensure the software is fully functional, the code is clean.
Our boilerplate framework for E2E tests is based on Selenium. The Artillery framework is used for load testing services. Testing and quality assurance are mandatory for all software.
There is a great variety of tests, among which selected suitable for your product, but all projects should undergo the following:
- Manual and automated testing
- Unit testing
- Coding review
- End-to-end testing
- User acceptance testing (UAT)
In addition to these tests, the developer may suggest additional tests. For example, testing the application on different computer operating systems, on different devices, and/or with different web browsers, conducting load testing, additional testing of load times, and high-traffic performance.
We will test the system to ensure it is bug-free—if potential bugs or defects are discovered, our developers will address them immediately. As soon as bugs are fixed, the design is ready, and the project is considered completed, the product's final iteration can be released.
Deployment and release stage
In this step, the product is ready for release. We divide it into 3 key practices:
- Covering code in tests. Quality assurance tests are conducted before the product is released to ensure it works properly. The code must be clean, and if any errors or bugs are found, they should be addressed by the development team as soon as possible
- Applying CI/CD pipelines
- Product release. After ensuring the software works as expected, the product becomes available for end users
Maintenance
The software is now fully deployed and accessible by customers. As a result, the product enters the maintenance phase. To ensure that the software runs smoothly without any bugs, the development team provides regular support to the customer. Customers can benefit from new iterations of an existing product over time.
Summer up
It is important to clarify your thoughts and ideas before you begin developing your software so that they can be shared and understood consistently and easily.
As a result, it's hard to tell how long it takes to build an app. The software project's pre-discovery and discovery phase may take 1-3 months. But the development phase can take much longer—it can be a year or even more. Many of our clients who want to actively develop their projects stay with us for 3 or more years. Overall, project duration is heavily influenced by the size and complexity of the project.
Sir John Monash Centre is one of the clients that have stayed with us for more than two years. At the initial stage, both teams worked fruitfully, and you can see the results of the work in the case.
What else affects the duration of the project
When any of the following apply to a project, it is considered large or complex:
- Involves 25+ screens in use
- An administrative portal and a user application
- Supports multiple platforms (web, tablet, phone, iOS, Android, Windows Phone)
- Multi-system integration (security systems, payment gateways, CRM systems, ERP systems, HR systems, etc.)
- Data migration from an older system
- Complex business logic
- Requires complex reporting
- A user application and an administration portal.
Another factor that can affect the timeline of a project is the budget. Project managers are responsible for monitoring these types of risks to identify them early and mitigate them.
- The project's requirements or design change after it's started
- When working with third parties, there may be delays, such as not receiving technical documentation, credentials to test systems, or support on technical questions
- Uncertainty in the system design or missing requirements
- Multiple stakeholders providing inconsistent directions
- Implementing new technologies
- Migrating data with bad data or missing data.
Conclusion
How many hours does it take to build an app? From my own experience, unfortunately, you won't know the accurate estimate until the project is complete. It depends on your team's expertise, your development methodology, and the complexity and requirements of the project. There will always be some risks and uncovered black boxes along the road. According to your project's requirements, this process can take 4-9 months or even more.
But you will be pleased to know that you have the tools to manage this process. The key to project success is knowing the problem and striving to solve it rather than developing something that already exists just because it's already worked for another company. This approach will allow you to maneuver your dedicated team and achieve the needed results promptly.
Not so far, Mad Devs developers have participated in an educational project MegaUni. Collaboration between MegaUni and Mad Devs led to creation of an educational platform that is more than a decent solution for universities. Check out this case study if you want to develop the project from scratch.
Latest articles here
