How to choose tech stack for your project

The decision is nothing but trivial because the number of moving parts you’ll need to take into account (and even compromise on some if needed) is enormous. Every piece of the stack and all of them combined exert a considerable impact on the usability, performance, security or quality of an application.

A decision of which tech stack to choose depends on a set of business- and scope-related factors such as your business position, application size or budget. If you’re a startup with the goal to test your business as soon as possible, you’ll use different tools and technologies than an enterprise scaling up an existing solution that serves hundreds of thousands of users.

What is tech stack composed of?

A technology stack is a set of tools, languages, frameworks, and other components of the application. It affects the application’s performance (and therefore user experience) which makes it either a success or failure factor. But the relationship works the other way round as well. The type, size, or purpose of the application indeed impacts the architecture, design, and, of course, technology stack.

Web stacks consist of layers of components that run pretty much everything both on server-side and client-side, from databases to server administration and more. Let’s take a look at what the role of each of those layers is.

A typical tech stack composition

Client-side technologies (frontend)

As you might have guessed, the client-side is where the interaction with the user (client) takes place. Depending on the type of application (web or mobile), the user would interact with it via a web browser or a mobile device.

Digging a bit deeper into details, we can list three main technologies used in frontend (four if mobile apps fall within this group):

• JavaScript is a scripting language that allows web pages to be interactive and this way enhances user-friendly experiences, e.g. thanks to simple or complex web animations. JavaScript comes with a rich family of frontend frameworks that provide developers with packages of functional ready-to-use code, thus saving the development time. Angular, React, and Vue belong to the family.
• HTML (Hypertext Markup Language) tells the browser how to display the structure of information on a web page. It uses a set of predefined tags (called markups) to define whether a component is a piece of text, video, image, hyperlink, or a container holding multiple components.
• CSS (Cascading Style Sheet) styles the content defined by HTML. As such, it frames the looks of each item a user can see on a website. What’s more, thanks to CSS, developers can easily apply different fonts, sizes, colors or shadows to text, buttons, and boxes determined by HTML.

Server-side technologies (backend)

A backend tech stack consists of five major components:

• Web framework which, by definition, is a set of components (on top of a programming language) made to simplify the development process. Sounds more than good, doesn’t it? Especially that different frameworks are made to solve specific kinds of problems. With tens of frameworks to choose from, making the right choice becomes just as difficult as it is essential for a project's success.
• Programming language being a set of commands, instructions and other syntax used to create a computer program. Programmers use the so-called high-level languages to write code in a natural fashion. The number of options to choose from is immense, from Python or Go, PHP, Node.js or Ruby.
• Database - an organized collection of information. Here’s where users and app data is stored and updated. Depending on the application architecture and purpose, there are several types of databases to choose from, relational and non-relational being the most popular. That’s another choice to make when choosing a tech stack.
• Web server to handle HTTP requests coming through the browser. The four main types of servers are Apache, IIS, Nginx, and LiteSpeed.
• Operating system - software that acts as the interface between the end-user and the hardware (being a graphic card, processor, etc.). It handles CPU, memory, and storage management, making sure each program gets what it needs.  

Solution tech stacks - plenty of options to choose from

A typical stack contains layered structures of technologies developers use to build software. There is a rich choice of different tech stacks out there, some of which create entire ecosystems that support programmers in the development, deployment, and maintenance of software applications.

Almost all popular programming languages are a part of a technology stack. Whether you use Node.js, Python, or PHP, you can find a ready-to-use set of technologies that work together. Let’s take a look at the brightest stars that cover diverse programming languages and runtime environments.

LAMP stack is a classic used in PHP applications. Developers appreciate it because of its scalability, security, and customization options. LAMP stands for Linux (development platform being the top choice for 76% of professional developers), Apache (web server), MySQL (database), and PHP (programming language), and comprises a solid base for web applications built with Laravel, Drupal, or Wordpress.

MEAN stack is a JavaScript stack known for a gentle learning curve (JavaScript everywhere) as well as flexibility and high performance. Developers use it to build dynamic websites and web applications with Node.js runtime environment and Angular frontend. M stands for MongoDB database and E for ExpressJS framework.

There’s also a variation of MEAN called MERN stack, where React/Redux frontend replaces Angular. Hence, the selection between the two comes down to choosing between Angular and React. Considering the popularity of React, this set is currently the most-used JavaScript stack for single-page applications.

Python-Django stack uses Apache web server,  MySQL database, and Django framework. Because Django offers an unusual simplicity of coding, it’s a popular choice whenever you’re aiming for rapid prototype releases and frequent iterations.

Wins stack applies to a solution stack fully based on Windows services. A Wins stack includes technologies such as Windows Server, Internet Information Services, .Net, Microsoft SQL Server.

Serverless stack is based on cloud solutions such as AWS Lambda by Amazon, Google Cloud Functions, or Microsoft Azure Functions. In this model, serverless computing provides a platform for users to develop, run, and manage full-stack applications. Development teams often advise using the serverless stack for large applications that need to deal with occasional traffic peaks or a considerable number of end-users. The biggest advantage of serverless tech stack is that you pay only for the resources your application consumes. Still, it does not mean that a serverless stack would always be the most cost-effective choice.

Besides some popular options, there are numerous custom-designed tech stacks that fit non-standard software requirements. The key to a successful tech stack choice lies in understanding the nuances behind functional and nonfunctional requirements. And this brings us to the list of factors to consider when selecting the stack for your app.

Cherry-picking the tech stack: what (and what not) to consider

Although it seems tempting to take a look at the most successful startups out there and simply copy their tech stacks, that’s the shortest way to a big failure. Why is that? Firstly, there are no two companies in the world that use exactly the same technologies and tools. Secondly, the tech stack is like a tailored jacket – it suits the person (or business) it was made for, with all restrictions coming from their business model, hiring challenges and, eventually, the project scope.

In the next paragraphs, we’ll take a closer look at the variables that play a significant role when deciding on a tech stack.

Practical reasons

Let’s set the application scope aside for a moment and focus on some practical questions that are often (unrightfully) neglected by startups.

• Workforce availability

If you have your own small team, for sure they have their preferences when it comes to programming languages and frameworks. Maybe they’re faithful to good old PHP or, on the contrary, have a fierce need to test every new framework that appears on the horizon. As much as the latter option looks exciting, it can also be a threat to your project – especially once you need to extend your team.

It’s no secret that more developers are familiar with Java or Python than Rust or Golang. The less popular the language, the pricier the developer's time. Choosing a tech stack that’s stable, proven, and well-liked opens the door to a broader talent pool and easier (maybe even less expensive) onboarding.

• Scalability

How soon and how fast will you need to scale? That’s another practical question to solve in order to choose the right tech stack. If you expect your application to skyrocket the number of requests, e.g. before Black Friday or Valentine’s Day (horizontal scalability) you’ll need technology that handles heavy loads.

On the other hand, if you’re about to release the first version of your product and then build it up according to the feedback collected from the market, you’ll probably add a lot of new services to your application (vertical scalability).

Cloud computing or microservice architecture might be the direction to opt-in for. However, not all applications require such solutions. There are numerous options for scalability and a reliable tech partner ought to help you make the best-educated choice.

• Additional costs

The most neglected (and yet) a very practical thing to take into account is the budget. I don’t mean the budget you’ll use before you release the application. I mean additional spendings like server infrastructure, tools licenses, frameworks (paid or open-source), the cost of scaling the app infrastructure, etc. After all, the release date does not mark the end of the development. If you decide on building a web application, for sure you expect to scale up in the future.

• Fashion or a trend?

Developers like to experiment. According to a survey conducted by Stack Overflow, 86% of professional developers learn new frameworks. That’s especially common on the frontend as the JavaScript community is extremely fertile when it comes to creating new frameworks.

Source: Stack Overflow

When thinking about the stack for your project, however, you need to be more far-sighted and pay attention to whether the technology you consider is a fad or an established trend.

How to tell? One of the ways is to check whether the technology you’re about to use has:

• rich and well-maintained documentation – makes it easier to implement new features
• a significant number of contributors – provides updates of existing open-source libraries
• a fair number of Stack Overflow questions – represents the overall developers’ interest in the technology
• an engaged and active community – is an invaluable asset in case of non-standard problems

New frameworks or architecture patterns may be fun to use at the beginning but cause problems on the way.

Functional reasons

Now, let’s move to functional matters. Apart from scalability, talent availability, or post-development costs, there are also more technical questions to answer.

• The size and complexity of your project

Prototypes, MVPs, working applications, enterprise-class – software complexity can vary significantly, depending on the industry, goal, and purpose. The criteria upon which one can tell the small apps from the big ones are not universal, but in order to make things simple, let’s assume the following:

🟠 Small applications can enlist (among others) projects such as landing pages, single-page applications, showcase pages, event applications, or online stores built on templates and ready-to-use CMS systems. They don’t require any custom solutions and rely on standard app architecture.

🟠 Mid-sized applications require some level of customization, both on the server and the client-side. They often create entire ecosystems of connected web and mobile applications. Unlike small apps, they often require a complex stack such as MERN, MEAN, or similar. We can count in financial apps, enterprise software, or e-commerce stores to the mid-sized company.

🟠 Large applications rely heavily on custom solutions, or new technologies, starting from multi-tenant infrastructure, multiple user permission levels,  machine learning algorithms, dedicated integrations, and many more. Their development calls for a combination of tools, frameworks, and technologies that are able to provide the right level of security, performance, and user experience. Most social networks, video-streaming platforms, and SaaS applications belong here.

• Time to market

An important variable to look at is the expected timeline of your project. Time constraints can force the team to think outside of the box and come up with smart suggestions to speed things up. Some technologies are faster to develop with than others, others ensure better performance on a large scale. For example, Python is nicely set for machine learning projects while Node.js is a go-to for real-time applications or IoT implementations (or both at a time as it was the case with our home-made booking system for meeting rooms). It’s good to list the pros and cons thoroughly to avoid getting stuck with a stack that is slowing you down.  

• Architecture

Finally, there are some architectural choices to make. Does it make sense to separate frontend and backend repositories? How to design permissions policy for different types of users? Will my application require microservices? If so, which technology is optimal for a given part of my app? These are only some of the questions you need to put on your Q&A list. Others should relate to matters like security level or compliance (especially in the case of healthcare or legal applications).

Tech stack for your application

With so many available tools and technologies, selecting a tech stack is not a piece of cake. If done right, it will ensure high performance, smooth scalability, and delightful user experience. If done wrong, it can generate financial losses coming from architecture re-designs.

When choosing the stack, always keep in mind the specific requirements of your project. Together with practical and functional questions, they will map the direction to follow. If you need to move fast and don’t have the time or resources to consider all possible options, you can always reach out to IT solution architects who make such choices daily.

Get in touch with our software consultants today to prevent costly rework and turn your project into a success!

‍