As software engineers, we should be familiar with at least one framework or technology that is beyond basic. An understanding of this toolbox piece will make your job much easier in the long run.

N-tier architecture is a way to organize an application into different layers, each containing their own functionality and components. Each layer is connected to another via communication protocols such as HTTP or RPC.

The reason why it’s so important to have some knowledge about n-tier design is because most applications you work on use at least a couple!

For example, almost every website you visit uses something called the “web server” to provide end users access to resources (like Google or Facebook) on a remote computer. This web server connects directly to the internet and receives requests for content from users.

Most business apps rely heavily on a database to store information, which is where most companies draw their line when choosing their frontend platform. Since databases are already available across many platforms and settings, using them as our backend makes sense.

Making assumptions about what technologies other people use can limit your career opportunities later on. By being more aware of how different tech stacks fit together, you’ll solidify your understanding of software engineering.

This article will go over the basics of n-tier design and some examples of popular architectures made using these concepts.

The three-tier architecture

In most cases, starting out with a two- or even one-tier application is the best way to develop if you are new to web development. After all, it’s much easier to learn how to build an app using only PHP, Python, Ruby, etc., than it is to dive into more sophisticated languages like Java,.NET, or HTML5/CSS3.

That said, as your website grows in size and scope, it becomes increasingly difficult to separate business logic from front end code (HTML, CSS, JavaScript). This is where things get tricky.

At this stage of growth, there's often not enough time to devote to both areas properly, which can lead to suboptimal performance and functionality. It also makes developing features slightly harder - you'll have to do some backfilling before adding advanced features.

The two-tier architecture

With the two-tier design, there is a database that contains all of your information and then another layer which accesses this data.

This second layer is called the presentation layer or logic layer because it takes care of how everything looks on a screen, such as what content goes in a header, footer, list, etc.

The third tier is where most people get confused about n-tier when they first learn about it. This middle layer is referred to as the business layer or domain model.

This is not actually part of the three main tiers but some experts include it because this layer doesn’t directly interact with either the presentation layer or the database, just like the other two.

Instead, the business layer handles things like calculations, validation rules, and more complex functions that don’t fit into the others’ scope. This is why it's sometimes called “the fat middle.

The one-tier architecture

In the early days of software, there was only really one way to organize applications. It was called the one-tiered approach or, more commonly these days, the monolithic approach.

In this style of application design, all functions are housed in just one file or set of files. For example, if you look at most web sites today, they contain a home page, an about us section, links to different areas of the site, and maybe even some interactive features (i.e., blogs, chat, etc.).

These types of apps are typically built using JavaScript, HTML, and CSS. By separating out these functionalities into individual files, it is easy to manage versioning and reusability.

However, what happens when someone wants to add new pages or feature sections? They have to edit every file that contains code related to those things! As you can imagine, this quickly becomes very difficult to coordinate.

Furthermore, since all content and functionality live in separate files, it is impossible to easily share app components across domains. This is why many large corporations use WordPress as their main website platform — because it is already well-established and has lots of plugins available for free.

The micro-tier architecture

In some cases, it is not enough to have just one database per app. You may need several databases for your apps or at least want to consider this as an option. This is called a multi-database system or sometimes referred to as a n-tiered architecture.

A common use case of having separate databases is when you want to give users access to different parts of your site or applications. For example, say you create a website that has a community area and a business area. Users can login into each area using their own accounts.

By giving users their own account in a separate database, they no longer have access to the other areas and apps. It also gives you more flexibility in how you organize your data since you do not have to worry about permissions.

The service-oriented architecture

An example of an internal organization using a n-tier approach is what we refer to as the “service oriented architecture” (SOA) approach. A lot of people get this term confused because it looks similar to the other two terms, enterprise system and software lite.

What makes SOA different than either of those two concepts is how many tiers it has. In fact, some describe it as having zero tiers! This article will talk more about why that is important later on in the post.

But for now, let’s look at a basic example of an internal organizational structure using an n-tiered design.

In this example there are three layers: back end services, middleware, and front ends. Back end services handle all web server functions such as HTTP requests, DNS resolution, database access, etc. They also handle routing of these requests to specific middleware or front end applications depending on their function.

The middleware layer acts as a controller by passing messages back and forth between each tier. For instance, if a request comes into the back end services, then the next piece of computer code would be the middleware which decides whether or not to forward that message onto another backend service, or on to a front end application.

Front ends like you probably use daily mobile apps are part of the middleware layer.

The domain-driven architecture

An alternative approach to traditional large software architectures is called n-tier or, more commonly these days, non-relational database design. With this approach, your tiers are not separate applications but instead discrete components of one larger application that get linked together through interfaces (layers) in a logical way.

N-tiered designs typically use a layered pattern where each layer interacts with only layers above it and below it.

The term “n” here refers to the number of layers in the system. For example, two-layer systems have an interface between them, while three-layer ones include both an API and an implementation for each other. Four-layer apps usually have an API, an intermediary business logic layer, and an underlying data storage layer.

This article will focus mostly on four-layer databases and APIs, but many of what we discuss can be extended to five- or even six-layered systems as well.

The cloud-native architecture

As mentioned earlier, as technology continues to evolve at an incredible speed, so do application architectures. Application frameworks are moving towards more modular designs that can be separated into separate layers or components.

This is called n-tier software design. A common example of this is what we refer to as the “cloud native” architecture. Just like how most major tech companies have their own internal cloud platform these days (Google, Microsoft, etc.), applications now use a similar open source toolkit to deliver content through different platforms with different APIs.

The term “cloud native” was first coined in 2016 by Matt Richardson of ThoughtWorks. He described it as referring to architectures designed for efficient deployment and management in a distributed computing environment which utilize advanced networking technologies such as containerization and microservices.

Since then, the word has become synonymous with this approach to building apps. Why? Because it offers many benefits over traditional monolithic applications!

Given all those reasons, let’s take a closer look at why creating an app that uses a n-tier design is a good idea. Then, I will discuss some strategies for implementing one using PHP and MySQL as examples.

Broken down into three main points, here are the advantages of adopting a n-tiered app design:

1. Separation of concerns

In computer science, a concern is defined as a function or set of conditions that affect something related to your app.

The mobile-first architecture

With the explosion of mobile devices, there is now an always-connected device user base that software companies need to cater to. Since most users access the internet via their phone, it makes sense to develop web applications exclusively for phones or what’s called a mobile first approach.

This way, the browser becomes your interface and you can use HTML, CSS, and JavaScript to build your app. More advanced features like jQuery are already built in so you don’t have to worry about adding them later!

N-tier refers to having separate components (layers) of the application which work together to form the finished product. This structure allows each component to be upgraded or replaced without affecting the rest of the app.

For example, if one layer of the n-tiered system breaks down, you can simply remove it and everything will keep working because the next level up takes care of the rest. Technically, this is referred to as microservices but they both describe the same concept of having discrete modules that can be independently updated and deployed.

However, not every organization has the internal resources to implement such a system so it is important to know what kind of setup is feasible before diving into the hard parts.