N-tier architecture is an architectural style that breaks down your application into separate components that work together to create, manage, and present data. These components are typically referred to as layers or tiers.

The term “N” usually refers to how many levels of abstraction you have in your system. For example, most computer programs start with a layer called assembly language, then go up one level to machine code, and finally user interfaces such as Windows or Android apps.

By having these different levels of software, developers can easily add more functionality to a program by creating new layers of software. This concept has been around for a while, but it really took off after World War II when computers became widespread.

Since then, this approach has become very common because not only does it make adding features easier, but also allowing other people to develop part of your app makes it more scalable. Even if you're the main developer, using n-tier technology can help give you and others access to all parts of your applications.

There are several types of N-tiers, but my favorite is the Model - View - Controller (MVC) pattern. In this article I will discuss why the MVC pattern is important, and what each tier means within it.

2nd tier: Business logic

The second level of layering is business or logical layer, also referred to as the domain model. This layer contains all of your application’s logic.

Business classes contain functions that manipulate data and state within an applications internal setting. These are things like finding user information based on their email, creating new users when someone logs into the system for the first time, calculating gross sales for employees, etc.

These types of functions are called business rules or actions. Because these are occurring inside the context of a functioning app, they will always be executed!

The beauty of this layer is how testable it is. Each individual class can easily be tested in isolation. Testing all layers together isn't too easy due to dependencies, but testing each component separately is much easier.

There are many ways to organize this second layer. Some people stick with traditional OOP while others use MVVM (more about those later). What matters most is that you create functional units that relate only to other similar units.

This way, changing one part of the algorithm doesn’t require altering another piece because they're separate pieces. Reversing a string does not require rewriting a more complex calculation - just split up the work appropriately.

3rd tier: Data access

When developing applications that require significant amounts of data, you will need to determine what technology best fits your needs. You can choose between using raw SQL queries, ORMs (Object-Relational Mapping), or even fully fledged database management systems (DBMSs) like MySQL or Oracle.

ORM’S take care of all the heavy lifting for you by interacting with the underlying DBMS, while some offer additional features such as cache storage or migration tools. The two most popular ones are Entity Framework and NHibernate!

Both of these use an object oriented approach which makes it easy to work with relational databases. They both have their strengths and weaknesses, so choosing one over the other is mostly personal preference.

We will be covering both of these technologies in more detail in future lessons! For now though, just make sure you pick a good data access layer and get familiar with it.

A common misconception about web development is that every time you create a new page/application, you must start from scratch and re-design everything. This isn’t always the case and there are many ways to keep things consistent and efficient.

4th tier: Business logic

The fourth layer of an M-V-C pattern is business or business logic. This is typically considered the highest level of abstraction in most architectures, as it is the most specific layer. At this level, you will find things like how many products users can purchase before being terminated from your site, what actions users can take on a website, and more.

Business logic is usually very complex. It is not easy to add new features to business logic, nor are there hard and fast rules for using it. What people do make recommendations about however is keeping the layers separate.

This makes sense because even if these other layers are pretty simple, adding extra functionality at the business logic layer is difficult. For example, let’s say you have an online shopping cart that does basic checking off items and removing them form a cart.

You could easily write some code at the database layer that checks whether or not someone has added an item to their cart and then removes it, but what happens when they place another product into their cart? You would need to check that against the previous list!

This sort of thing becomes very complicated quickly so having a separate business logic layer is important.

5th tier: View

The fifth layer of an MVC application is the view. This is what users will see when they access your website or app. Depending on which platform you use, this could be through a browser, iOS device, Android phone, etc., so it must be versatile.

A web page is just a collection of tags and content that are linked together. A browser makes sure all these components are there and works with each other, so the browser becomes the limiting factor for how well you can design a given webpage.

By having separate layers in your MVC architecture, the next logical step is creating separate views for different pages.

These individual views are made up of specific elements such as headers, paragraphs, pictures, and interactive features. Using proper HTML, CSS, and JavaScript, developers can make very complex layouts and stack them on top of one another to create a rich user experience.

There are many ways to implement views in MVC applications. Some people organize their files by category (for example, navigation, content), while others use directory structures to group similar elements together. Either way, don’t get too attached to any particular organization method – try out some variety!

Any element that makes up a view can be defined separately. For instance, using Bootstrap, you could define a header component, a body component, and a footer component. Each of those three pieces can have its own style, color, and text easily.

6th tier: Database

The sixth layer of an MVC application is your database! Depending on how much data you have, you can choose either use MySQL or SQL Server as your back-end service provider.

MySQL is a common DB choice because it’s very accessible and there are many free tools available for it. You will need to ensure that you know basic syntax before starting to code, but overall, the tooling is pretty good.

If using Microsoft Office products such as Excel or Access, then switching over to SQL Server may be more familiar to you. There are several ways to go about setting up this connection including through their own software or via third party applications like Google Chrome OS app databases.

To keep things organized, most people create separate tables for different areas of the site. For example, if your site has a comments section, a users table, and posts with comment replies, then these would all go into their respective databases.

7th tier: Testing

A very important part of any software development process is testing, ensuring that your code works for all scenarios. This includes making sure it functions properly under regular use cases as well as when it is being actively used by users.

Testing is one of the most crucial parts of any project, especially web applications where user experience can be heavily influenced or even ruined if there are major issues.

As you begin writing logic for different layers of your application, make sure to test each layer! You should have no issue creating tests for controllers since they are mostly JavaScript files with some PHP embedded into them, but what about models?

Models are an integral piece of your app so it makes sense to have at least basic model testing done before moving onto the next stage. There are many ways to do this, but the easiest way I know how to describe is using something called Test-Driven Development (TDD).

What is TDD?

Test-driven development was created by Kent Beck back in 2004. It was designed to help developers write better quality software due to two main concepts; Writing a test first and then coding up whatever functionality comes after the test is passed.

The term “test” in these terms refers to a function or set of conditions which will determine whether the product being tested succeeds or fails.

8th tier: Hosting

In this chapter, we will talk about the eighth level of MVC architecture- hosting. This is typically done through an online platform or service that hosts your website’s files and information.

There are many different types of platforms you can choose from, such as Amazon AWS, Google Cloud Platform (GCP), Microsoft Azure, and more.

This isn’t necessarily a bad thing! As mentioned before, it’s totally fine if you're already using one of these services for other things.

What is important to know is that most free tiers of hosting come with limited features. Some of these limitations include a maximum number of pages per domain, certain plugins/themes, etc. — all of which can be overcome by paying for additional plans.

9th tier: Maintenance

A common mistake that many beginner web developers make is trying to do too much with their application. They start adding new features or changing things around to feel like they are making progress, but then their app becomes hard to manage as there is so much content and functionality.

This can be even more difficult to achieve once the app has gathered some momentum.

As your app grows in size and users, keeping up with all of the changes can become time consuming and expensive.

It’s important to focus on fine-tuning and enhancing the main components of your site instead of adding extra layers which may not get used.

That way, you will save time and money in the long run!

By separating out different functions into separate files or tiers, it is easy to add new pieces to your website later. You could also take this one step further by using an open source tool or framework to create these additional pieces.