Technology evolves faster than any sector in business. In the blink of an eye, something new has arrived to become the darling of enterprise companies everywhere. Take containers, for instance.
Prior to container technology (and especially Kubernetes), businesses relied on monolithic application stacks for the deployment of apps and services. One great example of a monolithic stack is LAMP (Linux, Apache, MySQL, PHP). That stack has been helping empower businesses for decades.
But, as we said, evolution happens and it does so very quickly.
These days, fully realized tech stacks appear as quickly as simple applications once did. And developers are taking bits and pieces and putting them together in ever more creative ways until the market is flooded with new and different stacks.
This, of course, begs our first question.
What is a Tech Stack?
To put it simply, a tech stack is a combination of programming languages, frameworks, and tools that come together to make it possible for developers to build web or mobile applications and services.
Let’s take the LAMP stack as an example. This very popular stack includes:
- A programming language (specifically, one for CGI scripting) – PHP
- A web server – Apache
- An operating system – Linux
- A database – MySQL or MariaDB
With this stack, it’s possible to deploy powerful and dynamic applications for many different purposes. However, that combination isn’t the de facto standard by which all stacks are built.
This is especially so in the modern, mobile age. Today, software engineers need the ability to develop and deploy their apps much faster than what a LAMP stack offers. That’s where the framework comes into play. When a framework is added into the mix, the work is more efficient and less redundant.
A more modern stack can be broken down into 7 different categories. Each stack or service can be then stacked upon other stacks/services to create a robust and complete application or service.
Operating systems/Programming Languages
This would be the base stack for which everything else is built. For this stack, you must choose an operating system and the necessary programming languages for the project. The operating system you choose will mostly depend on either your comfort level or the requirements of the other stacks you will use. In many cases, the most popular operating system for tech stacks is Linux.
The programming language, on the other hand, will be determined by the project. You can use Java, JavaScript, .NET, C++, Ruby, Python, or any language that makes it possible to develop the application or service.
Servers and Load Balancing
Here we have the category that involves servers as well as the hardware/software for content distribution networks, routing, caching services, resource management, RBAC, foundational services (such as compute, storage, and networking). This particular stack makes it possible for applications and services to receive requests from users and applications, run smoothly, and scale as demand rises. An example of this is the AzureStack, which includes a load balancing component.
Data storage and data querying
At this level, you’ll find a stack that consists of relational and non-relational databases, as well as data warehouses, data lakes, and data pipelines. Without this stack, your applications can’t be dynamic in nature, nor can they store data for later querying or usage.
The data stack depends upon input from data sources, which can come from numerous services like Facebook, Twitter, user input, Google Analytics, Salesforce, and (of course) databases. Once the data stack receives the input, it can then output information for business analytics.
Server-Side Stack
The server-side (or backend) stack adds much of the basic functionality necessary to build apps for the backend of your application stack. This will provide the necessary components for things like database communication, user request handling, and password resets. This stack is invisible to end-users and provides the backbone of the application.
The most common components of the server-side stack include programming languages like Python and Ruby, frameworks such as Django and Ruby on Rails, and the Node.js JavaScript runtime environment. The server-side stack can also include databases (such as MySQL) and web servers (such as Apache).
Client-Side Stack
The client-side stack (also known as the frontend stack) is what end users see displayed on their screens. This stack includes all of the necessary components to build the GUIs for your applications, such as HTML, CSS, and JavaScript, as well as the React and Angular frameworks. Some developers prefer to be full-stack developers, which means they can do both server-side and client-side development.
API Stack
This isn’t so much a stack on its own but is an absolutely crucial component to putting stacks together that can actually function. The API Stack makes it possible for you to connect all of the tools within your entire tech stack. Many of these API Stacks consist of thousands of pre-built APIs and are broken into 2 layers, one for services and one for infrastructure.
Monitoring Tools and Services
As you build your stack (or use a pre-built), you’re also going to need the necessary tools and services to monitor the health and performance of those components and services. And you might believe you can get away with only monitoring the performance of the app as a whole, but you might find it necessary (depending on how you’ve created your app or service) to monitor some of the individual stacks. You might need to place a specific monitor on your server-side stack, your data storage stack, or your operating system stack.
Getting very granular with your monitoring makes it possible for you to optimize the stack as a whole more consistently and reliably. On top of that, the data you receive from monitoring those individual stacks can be invaluable for tuning the performance of each individual piece. At the end that granularity makes it possible for you to tweak your stack to be as performant as possible.
Which Tech Stack Should You Choose?
The answer to this question is complicated because it absolutely depends on the nature of your project. But it’s critical to choose the right tech stack from the beginning. Should you go the wrong route, you could wind up having to start over halfway through the build process. And wasted time is wasted money.
It’s also critical to select a tech stack that is capable of scaling to meet your needs. For example, if you add a relational database into a stack that will be used for an app that will handle millions of requests per hour, your stack won’t be able to scale to meet that demand. Instead, you should use a NoSQL database for that stack.
There are a number of very popular tech stacks to choose from. Let’s take a look at some of the more popular ones.
MEAN
The MEAN stack is one of the most popular stacks for building dynamic websites and web applications. This stack is centered around JavaScript and is made up of:
- MongoDB – database
- Express.js – backend framework
- Angular.js – frontend framework
- Node.js – cross-platform server
The main reason why MEAN is so popular is because of its JavaScript-centered nature. That means your developers only have to concentrate on a single language (instead of cobbling together numerous languages for a single project). This makes it possible to quickly build apps and services, such as:
- Tools for workflow management
- Expense tracking apps
- News aggregation sites
- Mapping and location apps
- To-do and calendar apps
- Interactive forums
The reason why MEAN is so important is that it allows you to create scalable, cloud-native applications with a streamlined development lifecycle using a single language. With the help of MongoDB, your MEAN-based apps can work with large amounts of data, so it’s perfectly suitable for enterprise businesses. Finally, because MEAN has a built-in web server, deployment is quite simple.
MEVN
MEVN is similar to MEAN, but it swaps out Angular.js for Vue.js. Why? Vue.js is considered a great choice for both front- and back-side development and makes it very easy to deploy dynamic user-facing web applications. MEVN stands for:
- MongoDB – database
- Express.js – backend framework
- Vue.js – frontend framework
- Node.js – cross-platform server
For any developer looking to deploy front-end web applications with high rapidity, MEVN is the stack to use. And thanks to Vue.js’s ability to work with third-party services, it is quite flexible and can provide the best of both the Angular and React worlds. With the addition of Vue.js. your web applications will enjoy a remarkable performance.
The two main advantages of the MEVN stack are that it uses JavaScript through the entire development lifecycle and it has a more clear-cut client- vs server-side construction. And because Vue.js is easier to use than Angular, your developers will have an easier time getting up to speed with this stack.
MERN
This is another similar stack to MEAN, only it replaces the Angular.js frontend framework with React. Because React is one of the most popular frameworks for building single-page mobile applications, you can be certain MERN is one of the top stacks for building in the mobile space.
MERN stands for:
- MongoDB – database
- Express.js – backend framework
- React – front-end framework
- Node.js – cross-platform server
MERN offers a similar advantage as MEAN because it uses JavaScript throughout the entire development lifecycle. And because MERN uses the MVC (Model-View-Controller) architecture, the development process should be quite familiar to your engineers. Thanks to React and its asynchronous behavior, it’s possible to be incredibly performant in front-end applications. Finally, React is in use by some of the most popular websites in the world, such as Facebook and Dropbox, so it’s highly capable of serving the needs of any sized company.
LAMP
We’ve already mentioned the LAMP stack, but it must be included in this list, because of how widespread and crucial this stack is. The LAMP stack consists of:
- Linux – operating system
- Apache – webserver
- MySQL (or MariaDB) – database
- PHP – CGI language
The LAMP stack is often the base stack used for deployments of WordPress websites. It’s also possible to swap out various components. For example, you could change out Linux for Windows to make a WAMP stack or macOS to make a MAMP stack. You can put Perl or Python in place of PHP. But no matter how you piece this stack together, it’s one of the most popular web server stacks on the market and is used by millions of websites around the globe.
Meteor.js Stack
This is another open-source web development stack. Meteor.js focuses entirely on JavaScript to make app development much more efficient. With Meteor.js you can develop desktop, mobile, and web apps and even integrate with various frameworks and tools. The one downfall of Meteor.js is that it only works with the MongoDB NoSQL database, so your developers must know that tool in order to successfully build with this stack.
The advantage of Meteor.js is that you can write apps with significantly less code than other stacks. Meteor.js also allows you to build highly scalable applications. Other advantages include:
- Incredibly simple to use
- Seamless communication between the client and server
- Real-time testing tools
- Outstanding debugging features
- Plenty of packages and libraries to work with
Serverless
You might not think this is a stack, but it is. But what is serverless? Basically, it’s not managing servers. Cloud platforms like AWS, Google Cloud, and Azure offer serverless solutions. And all of these third-party hosts offer full stacks, which will include everything you need to build and deploy.
There are 3 main advantages of going serverless:
- It’s cost-effective
- You don’t have to worry about provisioning hardware
- It offers massive scalability
The Serverless Stack is an extension of AWS CDK and features a live Lambda development environment, support for setting breakpoints and debugging in VS Code, supports deploying to multiple regions and environments, includes higher-level constructs, and uses zero-config support for JavaScript, TypeScript, Go, Python, C#, and F#.
JAMstack
JAMstack isn’t nearly as popular as the other stacks in the list, but it’s becoming more and more useful for modern web development.
JAM stands for:
- JavaScript
- APIs
- Markup
JAMstack is geared specifically for developing websites. What’s important to understand with JAMstack is that development is completely disconnected from hosting. Because of this, you can build websites within your environment of choice, and then any changes made to the build are then deployed to a static site generator or CDN. Once the build is deployed the new site is generated.
JAMstack is a great option for building fast static websites and even automating the process (in a similar fashion as you would in CI/CD). It’s important to understand that you can select the components you prefer for each section (such as React for JavaScript, Elastic for API, and Gatsby for Markup). This makes JAMstack fairly flexible.
DIY
Here’s one of the best things about tech stacks. You might not find a current stack that meets the needs of your project. You know exactly what you’re building, but none of the stacks give you everything you need.
That’s when the Do It Yourself mindset comes into play. With so much technology available, you could cobble together a brand new stack to create exactly what your project needs. Maybe that project needs a LAMA stack: Linux, Apache, MongoDB, Angular. Or maybe it’s all about JAN stack (JavaScript, Apache, Node.js). You might even need to base your project on a LAN stack (Linux, NGINX, Node.js).
The beauty of tech stacks is that they aren’t immutable. In fact, there’s no limit to the stacks you can come up with. But if you go this route, it’s absolutely critical that you know what you need the stack to do, that the constituent parts can communicate with one another, and that the stack can deliver in terms of reliability, uptime, scalability, and flexibility.
If you were to cobble together your own stack, only to find out in the middle of the project that the stack won’t work, you’re back at square one. In the world of modern computing, stepping backward is akin to implosion. Your developers and your company must always be moving forward. If you opt to go the DIY stack route, do it properly and it will serve your needs well.
Conclusion
Tech stacks have been around for a very long time. But over the years they’ve evolved into very specialized tools to help make the jobs of your developers easier while making it possible for your business to deploy massively scalable, user-friendly applications that the public can use to interact with your company.
The single most important thing you should understand, however, is that tech stacks make it possible for your developers to make use of pre-built software, so they don’t have to reinvent the wheel every single time they start a new project.
With all of this technology around, application development is experiencing one of the fastest and largest periods of growth in history. Thanks to cloud-native, containers, web, and mobile app development, tech stacks are now more important than ever.
