Tech stacks – how to choose the right one?

Tech stacks - how to choose the right one?

In your business journey, there will sooner or later come the moment when you’ll have to start developing your digital product. The decision of what technology to choose can be on you, your outsourcing partner, or your CTO.

However, no matter who makes the decision, you, as a business owner, should know what influences the choice of the right tech stack and what impact the decision might have.

What is a tech stack?

To explain a tech stack, we have to narrow the context of what type of application we need.

Let’s say we want an app running in a user’s web browser. Then, we need to focus on the following:

  1. The front-end layer – the user interface and code running in the user’s web browser. It’s typically built using HTML, CSS, and JavaScript with frameworks like React, Angular, or Vue.
  2.  The back-end layer – the server-side code that runs on a web server and handles database operations, authentication, and other server-side tasks, typically built using programming languages like Java, Python, Ruby, or Node.js with frameworks like Express.js, Django, or Ruby on Rails.
  3. The database – the layer that stores and manages the application’s data, with two main types: SQL databases, which are relational and use a structured data model (e.g., MySQL, PostgreSQL), and NoSQL databases, which are non-relational and use a flexible data model (e.g., MongoDB, Cassandra).

From the options above, you can choose, for example, MERN (MongoDB, Express.js, React.js, Node.js) or Java + Spring Boot + PostgreSQL/MySQL.

When building a mobile app for both leading platforms (iOS and Android), there are several choices for the tech stack:

  1. Native App Development: Native app development involves building separate apps for each platform using the respective platform’s programming languages and development tools (Swift or Objective-C for iOS and Java or Kotlin for Android). Native apps typically provide the best performance and user experience but require more development time and effort.
  2. Cross-Platform App Development: Cross-platform app development involves building a single app that can run on both iOS and Android using a single codebase. Popular cross-platform development frameworks include React Native, Flutter, and Xamarin. Cross-platform apps can be quicker to develop than native apps and can reduce development costs but may have slightly lower performance than native apps.

Top factors for choosing the best technology stack for your startup

Availability Of Talent

Availability of talent is a crucial aspect when it comes to software development. The technology chosen will impact how easy/hard it is to hire talents. If you choose a tech stack that is less commonly used or has a smaller community, it may be harder to find skilled developers, be it a front-end web developer, a back-end developer, mobile app developer, data scientist, or any other role required by your project with expertise in that area.

Niche technologies, such as Scala, Clojure, or Haskell, were designed for solving specific, not general, problems and come with a steep learning curve. Their market is less liquid, translating into lengthy recruitment processes and the need to wait for suitable candidates.


The type of project you are working on can significantly impact your chosen tech stack. For example, a product that involves real-time updates or complex algorithms may require a different tech stack than a simple data-storage project.

What is scalability?

Scalability in software development refers to the ability of a software application to handle increased workloads without experiencing a decrease in performance or stability.

This means that as the number of users, requests, or data increases, the application should be able to continue functioning at the same level of performance without crashing or slowing down. In other words, the application should be able to scale up or down its resources, such as servers, memory, and storage, as needed to accommodate the workload.

Scalability can be achieved through various techniques, such as load balancing, caching, and horizontal or vertical scaling.

  • Load balancing: Distributing incoming network traffic across multiple servers to prevent any one server from becoming overwhelmed.
  • Caching: Storing frequently accessed data in a cache to reduce the need to retrieve it from the original source, thus improving performance.
  • Horizontal scaling: Adding more servers to the system to distribute the workload across them.
  • Vertical scaling: Adding more resources, such as CPU, RAM, or storage, to a single server to increase its capacity to handle a larger workload. Vertical scaling is the simplest method because it does not require code changes. However, other techniques need to be used when it is no longer possible to add CPUs, or the maximum size/performance of the database has been reached.

The meaning of performance in scalability

The performance of the back-end technology stack is a crucial factor in determining the scalability of a web or mobile application. The technology’s ability to process requests efficiently and quickly directly affects the response time and the number of requests that can be served.

Some technologies are designed to handle high traffic and are optimized for performance, while others are not (Python, for example).



Automatic scalability with AWS Lambda

Imagine you are building a web app. It will most probably have to do something with images, be it something as simple as enabling users to upload a profile photo. To deal with them, additional image processing is often required on the back end (such as creating thumbnails or generating multiple versions in different resolutions or formats).

During periods of high traffic, this image processing could potentially overwhelm the entire application, making it not responsive. However, if you use a cloud service like AWS, you can leverage AWS Lambda (for image handling).

Here are two advantages:

Scalability: Lambda is specifically designed to automatically scale and handle many requests. When a Lambda function is triggered, AWS automatically provides the necessary resources to process the request. This ensures that Lambda can dynamically scale up or down based on the incoming traffic, enabling the system to effectively manage a high volume of incoming images.

Pre-processing: Lambda can perform pre-processing tasks on incoming images, such as resizing, cropping, or compressing. By offloading these tasks to Lambda, you can minimize the amount of data that needs to be stored and transmitted. This can result in cost savings for storage and network usage.

In summary, AWS Lambda offers scalability and the ability to perform efficient pre-processing on images, making it a good choice for image-related operations within a web application.

Project size & complexity

For smaller projects with simpler requirements, a lightweight technology stack with fewer components may be sufficient, as it can help reduce development time and costs and simplify maintenance and updates.

However, a robust and scalable technology stack may be required for larger and more complex projects to handle the increased demands.

Which technologies are better for smaller/larger projects?

There are programming languages and technologies that are better suited for small projects compared to large projects. Here are two factors to consider:

Project scale

Small projects typically have simpler architecture and fewer requirements compared to larger projects. Therefore, languages and technologies that are easy to use and quick to learn, such as PHP, Python, and Ruby, may be more suitable for small projects.

On the other hand, larger projects require more complex architecture and advanced functionality, which may require more efficient programming languages, for example, Java or C#.

Time to market

Small projects often require quick deployment and low cost, so programming languages and technologies that allow rapid prototyping and development, such as Ruby on Rails or Node.js, will be the best option here. For larger projects, time to market may be less important than quality and scalability, so more efficient programming languages (Java or C#) may be more suitable.

It’s worth noticing that regular development will always take its time, so it’s wise to first think about what your goal is at the moment. Maybe you don’t need to develop anything at the point you’re at right now. If you’re at the idea/solution validation stage and care about fast iterations and results, you should go for no-code (or low-code).

Your plans

Every startup wants to become a unicorn, but some solutions will always stay local.

If your project is small and you know it won’t grow globally, it’s better to develop it with technologies that enable faster delivery at the cost of scalability.

For simple CRUD (Create, Read, Update, Delete) applications, a promising technology stack would be one that is lightweight, easy to set up, and provides basic functionality for database access and server-side rendering, for example, Ruby on Rails (Ruby, Rails, SQLite) – a popular web framework that follows the “Convention over Configuration” principle, making it easy to build simple CRUD applications quickly.

Additionally, it will be faster to resolve a bug, even when it’s being addressed by someone who didn’t originally develop that specific feature and needs to first familiarize themselves with it to some extent.

On the other hand, if you’re the “go hard or go home” person, want to build another Uber or Revolut, and are more than sure you’re app will be scaled, it’s better to choose older, battle-tested, and stable technologies, for example, Java + Spring Boot + AWS.

Budget size

If the budget is small, consider a no-code approach first. With a no-code product, you’re ready to validate the idea and show your ideas to investors. If you secure funding at this stage, you can later transition to building something more advanced.

If your budget is large, the choice of the specific tech stack is a minor factor. Access to talent is what really matters. The more talent available, the ultimately cheaper the development process becomes.

Ease of use and maintenance

When a tech stack is overly complex, it can be challenging to understand and maintain, especially if multiple people are working on it, as it might require specialized skills or knowledge.

Example: Suppose you have one relational database (e.g., PostgreSQL) in your project. You can add other databases (NoSQL, MongoDB) that are good in specific contexts. However, adding them comes with the cost of everyone needing to learn how to use them (handling and installation).

Moreover, a complex tech stack often requires a lot of customization, making it difficult to keep up with updates and changes to the technology and achieve compatibility with all its elements.

If you’ve started your project in one programming language, and there are more products to build within this one project, you don’t want to start them in different technologies. Why?

  • Codebase consistency: When all components are written in the same language, it is easier to maintain codebase consistency. This means that all code can follow the same conventions, guidelines, and best practices, which results in a more cohesive and maintainable codebase.
  • Easier communication: Having all components in the same language can make communication between teams easier. If all teams are familiar with the same programming language, they can easily communicate and collaborate on code and development tasks.
  • Reduced overhead: Using multiple programming languages can create additional overhead in terms of training, tooling, and maintenance. By using a single language, development teams can reduce the time and resources required to maintain and support multiple programming languages.


Quite obvious, but If your tech stack is not secure, it can leave your application or system vulnerable to cyber-attacks and data breaches. This can lead to the loss of sensitive data and damage to your reputation.



Java-based applications leading the way in the banking industry

Java is an undeniable queen of banking technologies. It was designed to handle large enterprise applications. The technology’s features, such as multi-threading, security APIs, and strong typing, combined with maturity and stability, make it the most popular programming language for building banking applications.

However, it doesn’t mean you can’t build a banking app using another programming language.

Node.js, for example, is a newer programming language designed for building scalable and lightweight applications. In the context of fintech, Node.js has gained significant traction due to its ability to handle high concurrency and handle asynchronous operations effectively.

However, while Node.js can be used to build banking applications, it may not be the best choice for specific applications requiring high performance, reliability, and security. Node.js also has a reputation for being better suited for building web applications and APIs rather than back-end processing.

Your exit strategy

If you plan to sell your startup or merge with another company, you need to choose a tech stack compatible with the systems used by potential buyers or partners.

Your technology stack can impact your merging decisions. If you use popular technologies, it becomes easier to merge as there is a higher likelihood of compatibility.

On the other hand, you may not acquire another company if they have a completely different technological stack. However, if you decide to merge anyway, it will come with additional costs. Operating within two technologies or rewriting parts of the codebase in another language (which also increases costs) are potential scenarios to consider.

Conclusion. Optimal tech stack

To sum up, let’s assume you’re a startup business founder and are about to start developing a digital product. What would be the optimal tech stack for you? We asked one of our most experienced developers, Jacek, for his opinion. Here’s what he said.

If I had to make a choice, it would be something like this:

  • Choose proven technologies – Node.js combined with a statically typed language (TypeScript). Traditional server architecture should serve you well, providing a decent development speed and flexibility without locking to a specific cloud vendor. It’s good to go for technological decoupling between the front and back end because it allows for separate development. The truth is you could also assemble a similar stack in other languages. Still, JavaScript has the advantage of being the only one that works in the browser and is used for front-end development.
  • PostgreSQL would serve as the database.
  • React, combined with Next.js, is suitable for the front end.
  • For the back end, it depends on what’s your priority. We can consider the “convention over configuration” and “flexible” approaches. In the case of the first alternative, the development goes “by the book” (here, the “book” would be your development framework). You have limited options for customization, which speeds up development initially but may become limiting later on. With the “flexible” approach, you have more control, but it comes with the necessity to write more code. So, for the “convention over configuration” option, NestJS could be considered; for a more flexible approach, choose Express or Fastify