How much will it cost you to build an app? A detailed step-by-step breakdown

Costs, costs, and more costs. This is what you need to prepare for if you’re developing an application. If you’re doing it for the first time, the amount of investment required might come as a surprise (and not the pleasant kind), because you may not understand where it comes from. In this article, we will look at how much money needs to be spent before you can even see the first results of the programming work, and most importantly – what exactly is behind the app costs.

As humans, we are naturally more willing to pay for a goal we want to achieve than for the means that help us get there. That’s why we begrudgingly pay for parking or shipping costs, considering them as “necessary evils.” We think of them as things of low value.

If you plan to create an application, you might think the same thing about the configuration work that is essential at the beginning of the development phase. It’s understandable that you can’t wait to see the first glimpses of your application in action. However, remember that ahead of you lies a demanding journey (also financially), and how you prepare for it now will impact the months to come.

In short, this journey will look like this:

1. Requirements Analysis and Design (costs)
2. Programming (costs)
3. Testing (more costs)
4. Deployment (only from this point on can you start seeing a return on your investment)
5. Maintenance (ongoing costs)

In this article, we will focus on point 2, which is the programming of the application. This is the most expensive stage of all, and before even reaching it, you will need to spend between 5,000 and 25,000 USD on the analysis and design of the application (depending on its complexity).

If you’ve got an estimate from a potential contractor in front of you, you may find a list of strange looking tasks which can colloquially be described as “getting everything ready.” Check out the following sample items and why they are essential:

1. Environment setup 

It means preparing the proper work environment for the developers, including installing the necessary tools, libraries, and software, as well as configuring components and cloud resources or on-premise servers. This is the foundation that allows development work to begin. Examples of tasks at this stage include:

• Preparing the application for containerization (Docker). This process involves packaging the application and all the necessary elements for its operation (such as libraries, tools, dependencies) into a container. Dockerization provides a “recipe” for building the application based on the provided code. Thanks to containerization, the application can be run in various environments (on different computers, servers, or in the cloud).
• Configuration of version control systems, such as Git, including the source code repository. In short, this involves creating a storage location for the code, to which additional elements (new parts of the code) will be added. Git enables code changes, tracks their history, and facilitates collaboration within the development team.

How much time does it take?

For a simple application, this stage may take a couple of hours. If the application involves a complex architecture and numerous tools, it could take over a week.

2. CI/CD configuration

CI/CD (Continuous Integration/Continuous Deployment) involves setting up a series of instructions by a server that automates tasks related to programming processes and deploying code to production. CI/CD eliminates the need to perform these tasks manually and minimizes the risk of errors and conflicts with existing code.

CI (Continuous Integration) means that every change made by developers (e.g., a new piece of code) is automatically added to the main version of the project, which is stored in a central repository. These changes go hand in hand with the previously mentioned Git system. Moreover, each change is immediately checked for errors that could potentially break the product. This is crucial because multiple developers often work on the same application. It is essential to ensure that the new code they independently work on does not cause conflicts. CI is like adding new parts to a machine – before they are permanently installed, they go through quality control to ensure they fit well with the whole.

CD (Continuous Deployment/Delivery) follows the CI (Continuous Integration) stage. Once it is confirmed that the new parts of the project are correct and work well with the rest of the program, they are “sent” where people can use them – for example, to a website or a mobile app. This is like the final packaging of a product and shipping it to the store or directly to the customer.

How much time does it take?

In very small projects the time needed to configure CI/CD starts from a few hours. The larger the project, the more time is needed. In large projects, it can take even several days. However, the benefits are significant: CI/CD speeds up the process of integrating new parts of code into the entire system without conflicts and delivering software to end users (to production). Therefore, the time spent configuring it is time saved in subsequent stages of software development (testing, deployment).

3. Database configuration

A database for an application is a “storehouse of information” organized to facilitate easy searching, browsing, and data management.

What can be stored in a database? Let’s assume you plan to build an online food ordering application. The database for this application would store information such as:

• Customer data (name, address, phone number)
• Restaurant information (name, menu, prices)
• Order history (what was ordered, when, to what address)

Databases are typically very extensive collections, and efficient use of them is crucial for the application’s performance and resource consumption (and costs). In short, an application is divided into: the Frontend (the visual part, i.e., graphical interface elements and all user interactions with the system) and the Backend (the server-side, responsible for logic and data transmission). It’s the backend that will connect to the database to retrieve, create, or modify specific information at the request of the user interacting with the frontend.

Applications often connect to various databases, which can have different structures, such as relational (SQL) or non-relational (NoSQL). Configuring the database at the initial stage of application development is a critical process that lays a solid foundation for storing and managing application data. It involves several key steps:

• Deciding on the type of database that best meets the application’s needs, depending on factors such as data type and performance requirements.
• Installing and configuring the database management system (DBMS). Depending on the type of database chosen, various management systems will be available: relational databases (e.g., MySQL, PostgreSQL), non-relational (NoSQL, e.g., MongoDB, Cassandra), and cloud solutions (e.g., Amazon RDS, Google Cloud SQL). This step also involves setting up the database system on servers, including configuring parameters such as capacity, connections, and security. For smaller projects, cloud solutions are often chosen (instead of local installation) because of lower initial costs and ease of scaling.
• Defining the database structure, including tables, columns, keys, and relationships between data.
• Setting access permissions and security for users and applications using the database to ensure it can share its resources with selected users.

How much time does it take?

The time needed to configure the database largely depends on its type and the size of the application, such as how many tables, relations, and data types need to be configured (for a relational database). For a very simple MVP application, the configuration usually does not take longer than one working day; for a medium-sized application, the time will range between 2 and 4 working days.

4. Project configuration

During the Requirements Analysis and Design phase, the team analyzed the application screens, compared them with technical and business requirements, and planned the architecture along with the recommended tools for the application. Now, in the early phase of development, it is time to translate these decisions into actual code. This will involve configuring libraries and installing packages that will make programming much faster and more efficient.

This configuration is done separately for the backend, frontend, and/or mobile platforms. It may involve tasks such as configuring routing, styling, state management, form validation and management, user session handling, file management, preparing API endpoints and data models, and many other tasks, depending on the specific application.

How much time does it take?

For a small application, the entire configuration can be completed in a few hours. If your application requires unusual functionalities or is simply large, the time required will increase.

5. Third party integrations

Applications almost always connect to other existing systems or external services. This type of integration aims to expand the application’s functionality, enable data exchange between systems, and increase efficiency and process automation.

What does this involve? Metaphorically speaking, for tailor-made products, after preparing the workspace (sewing machine, design), you now need “materials,” “threads,” or other product elements (“buttons,” “zippers”). These elements can be easily acquired and incorporated into your project, and creating them from scratch would be entirely irrational. After all, you don’t want to build a button factory if you plan to sew a suit.

Let’s go back to the domain of IT and use a few examples of integrations:

• Social media login: You want to enable users to instantly register and log in using their existing Facebook, Google, or Apple account.
• Mail delivery and email registration: Your application allows users to reset their password if they forget it. The application will send a password reset link via email to the address provided during account registration. In this case, you need integration with a service that will automatically send these links and relay the new password information to your application’s server-side. An example of such a service is SendGrid.
• Push notifications: You want your application to notify users of important events or changes, such as those requiring further action. This requires integration with services like Firebase or WonderPush.
• Payments: If your application involves purchases (e.g., an e-commerce app) or paid subscriptions, you will need to integrate with a payment system (e.g., Stripe) to handle common and popular payment types. Additionally, you won’t have to worry about data security issues, as the payment system provider will handle the storage of credit card data, not your database.
• Custom-made applications can be part of an existing system. For example, you have an extensive e-commerce application and need to create a dedicated loyalty program. The new application must access the resources of the existing one to efficiently receive and send data, such as user information or product-specific points. It will be necessary to determine how the two applications will communicate and how often they will do so.

How much time does it take?

The time required for integration with popular services is not difficult to predict. The majority of payment, email delivery, and push notification services offer comprehensive documentation that just needs to be configured with your application. The timeframes for the most popular integrations are as follows:

• Social media login: 4-8 hours per channel
• Push notifications for mobile applications (Firebase): 2-5 days
• SMS gateway integration: 2-3 days
• Email sending service, e.g., for password resets or purchase confirmations (SendGrid): 2-3 days
• File storage service, e.g., for graphic files (cloud storage: Azure Blob Storage, AWS S3, Cloudflare R2; alternatively on-premise storage: MinIO): 4-8 hours

Think about which external services will be most valuable to your users in the first stage of development.

If you need to integrate with your own existing systems or with more niche or older public services, the time required for that is difficult to predict. It depends on factors such as:

• System complexity and modernity: The more complex and older the system to be integrated with the new application, the more challenging the integration.
• Communication method: The most common is REST API, quite modern gRPC, alternatively GraphQL, or the less common and older SOAP API.
• Scope and quality of API documentation: Lack of documentation or poor-quality documentation can significantly extend the time required to understand and correctly use the API.
• Data formats: Differences in how data is stored, managed, and processed in both systems may require complex data transformations.

6. Configuration and implementation of the UI components

This process involves creating basic user interface elements, such as buttons and text fields, that will be used across different parts of the application. The goal of this stage is to ensure that all these elements look and function consistently, making the application easier for users to navigate and more professional. Once created, these components can be reused multiple times, speeding up the development of new features. Updating a single component updates it everywhere it is used.

How much time does it take?

The time required to configure components can range from one to several days, depending on the number of different elements and the level of customization needed for the application. For example, a new mobile application that is part of a larger ecosystem (such as a loyalty program) should visually align with existing UI guidelines, thus requiring more detailed configuration, even when using pre-built component libraries like Material-UI. If your mobile application’s appearance does not need to strictly adhere to specific brand guidelines or styles, you can significantly shorten this stage since there will be less need for extensive modification of ready-made UI kits. Don’t worry about losing the unique look of your application. Colors, fonts, icons, and graphics used in the application will be tailored to your needs, giving the product its own character.

7. Team meetings

Team meetings must fight for good PR in the “this meeting could have been an email” world. Not all meetings can be emails, and often it’s better if they aren’t. The team developing your application needs to communicate frequently and efficiently to ensure that priority tasks are clearly identified, dependencies and blockers are addressed, and everyone is aligned. Before you see tangible results from the development work, the team will spend considerable time in meetings to analyze the technical possibilities of various solutions. Meetings will be a constant part of the development phase. How many of them should you expect?

Software development is most often conducted using Agile methodologies. The process is typically divided into sprints (for example, two weeks), which include the following meetings:

• Planning meeting at the beginning of the sprint where the team defines the sprint goal, organizes the backlog for the upcoming days, and estimates the time required for each task.
• Daily meetings, short internal meetings of about 15 minutes each day, where the development team shares updates on their progress toward the sprint goal.
• Review meeting, a demonstration meeting where the team presents the progress of their work and collects your feedback.
• Retrospective meeting at the end of the sprint, aimed at evaluating the sprint’s processes and proposing improvements.

When you see “team meetings” in the estimation, don’t treat them as “chat breaks.” Instead, look at them as time dedicated to your project, during which the team ensures their work is high-quality, heading in the right direction, and that any incorrect assumptions are quickly clarified. It’s also an opportunity for you to respond to changing market needs in a timely manner (“The competitor’s app allows adding products to a wish list, let’s do that too”).

How much time does it take?

Regular meetings (planning, daily, review, and retrospective) take about 2-3 hours per week for each team member. This constitutes about 6% of a developer’s work time.

Podsumowanie

From a few days to a few weeks – that’s how long the work related to project initialization can take in the early stages of its development. The better thought-out and prepared the workspace and its tools are, the smoother the entire development phase will proceed. This investment will pay off in the coming weeks and months.