Multi-tenancy is an architecture style where a single instance of a software application serves multiple customers (tenants). It got popular with the rise of Software as a Service (SaaS) applications where multiple users or organizations use the same application while keeping their data isolated. Before Multi-tenancy, the bread-and-butter of SaaS applications was Single-tenancy architecture where each customer had their own instance of the application. Let's explore these concepts in detail.

Table of Contents

• What is a Tenant?
• Single Tenancy vs Multi Tenancy
• Diving deeper into Multi Tenancy
• Scalability in Multi Tenancy
• Multi Tenancy in Next.js

What is a Tenant? 🙋‍♀️

A tenant is simply a user (in a workspace), group of users or an entire organization that uses a shared application or a system. These tenants need to be managed effectively to ensure that their data is isolated and secure. All these come under Single and Multi Tenancy ways of managing tenants.

Let's dive deeper into these concepts.

Single Tenancy vs Multi Tenancy ⚒️ ️

• Single Tenancy means that each tenant has their own instance of the application, resources, storage, and database. Each tenant is completely unaware or isolated from other tenants.
• The degree of security and customization is high as each tenant has their own dedicated resources.
• Downside of this architecture is that it is expensive to maintain for the service provider as they have to cater to the tenant-specific resources.
• Multi Tenancy on the other hand means that multiple tenants share the same instance of the application, resources, storage, and database based on logical separation of data.
• This means that the service provider can optimize their resources and provide a cost-effective solution to the tenants. (Kind of a win-win situation)
• Multi tenancy has its own challenges like Data isolation, Security concerns, and Customization limitations.

Diving deeper into Multi Tenancy 🌊

Building - Apartment Analogy 🏢

An analogy that is often used while discussing Multi-tenancy is that of an Apartment building and Individual apartments.

• Apartment building represents the shared application or system that multiple users (tenants) are using.
• Each apartment/unit within the building represents a tenant.
• The building has shared infra like electricity, water, security etc. which are used by all tenants which is similar to the shared resources of storage, compute, and database in Multi-tenant architecture.
• Each apartment has its own separate living space, kitchen, bathroom etc which only belongs to that tenant. This is similar to how each tenant in a Multi-tenant architecture has their own separate data and resources within the shared application.
• This analogy highlights the core benefits of Multi-tenancy such as Cost Efficiency, effective resource utilization, and ease of maintenance.

Why Multi Tenancy? ❓

Multi tenancy does not mean that tenants are sharing data but rather sharing the same application instance while keeping their data logically separated. This is preferred when

1. Not breaking the bank is a priority.
2. Spend less time in maintenance and managing infra.

It's much easier to make a Multi-Tenant application act like a Single Tenant application (by providing dedicated resources) than the other way around.

Noisy Neighbor Problem 🏘️

• One challenge of Multi-tenancy is the "Noisy neighbor" problem, where one tenant's heavy usage can impact the performance of other tenants.
• Imagine if in an apartment building, one tenant throws a loud party that disturbs the other tenants. Similarly, in a Multi-tenant architecture, if one tenant consumes excessive resources, it can lead to performance fallbacks for other tenants.
• This happens when one tenant excessively uses CPU, memory, network bandwidth or storage which negatively impacts other tenants sharing the same resources.
• To mitigate this, the noisy neighbours can be isolated and handled separately by providing dedicated resources for them. This way, the performance of other tenants is not affected.
• A periodic monitoring and alerting mechanism is helpful to identify and manage noisy neighbors effectively.

Handling Customization in Multi Tenancy ⚙️

• Customization can be a challenge in Multi-tenancy as all tenants are sharing the same application instance.
• It's not as straightforward as in single tenancy where each tenant has their own instance. In Multi-tenancy, customization needs to be handled carefully to ensure that it does not impact other tenants.
• One of the ways it can be achieved is using Feature Flags.
• Feature flags allow for enabling or disabling specific features for individual tenants without affecting others.
• Other approaches include using Configuration files or Database settings to manage tenant-specific customizations.
• It's important to strike a balance between customization and maintainability in Multi-tenancy to ensure that the application remains scalable and easy to work with.

Ways of routing tenants 🚏

Routing tenants in a Multi-tenant application can be done in various ways depending on the requirements and architecture of the application.

Some common ways include:

• Subdomain Routing: In this approach, each tenant gets a unique subdomain. For example, org1.foo.com, org2.foo.com etc. The application uses the subdomain to identify the tenant and route requests accordingly. This approach is used by many SaaS applications. Sentry uses the subdomain routing for its users/organizations.
• Path-based Routing: In this approach, each tenant is identified by a specific path in the URL. For example, foo.com/org1, foo.com/org2 etc. The application uses the path to identify the tenant and route requests accordingly. Dub, Linear uses path-based routing approach.

Impact on SEO while using Subdomain vs Path-based routing 📈

Subdomains often have a concern regarding its influence on the website's rankings and overall SEO performance. Search engines treat subdomains as separate entities from the main domain, which means each subdomain requires its own SEO efforts including backlinks, content optimization, and authority building. In Path-based routing, all the content resides under the main domain, allowing them to inherit the SEO benefits of the main domain.

Subdomains is a better choice when the tenants require a distinct identity or branding (e.g., different products or services), while path-based routing is more suitable for applications where SEO is a primary concern (e.g content platforms, blogs etc).

Scalability in Multi Tenancy 📐

The two core things to keep in mind while working with Multi Tenancy is Data Isolation and Resource Management.

1. Data Isolation:

This simply means that I (as a tenant) should not be able to access other tenant's data and vice versa. This is important for security and privacy of tenants. Below are the different approaches to achieve data isolation:

1. Silo Model / Database level isolation: Each tenant has their own database instance. This provides the highest level of data isolation but can be expensive to maintain.
2. Separate Schema Model / Schema level isolation: Each tenant has their own schema within a shared database. This provides a good balance between data isolation and resource utilization.
3. Pool Model / Row level isolation: All tenants share the same database and schema, but their data is logically separated using tenant identifiers. This is the most cost-effective and common approach while building small to medium scale Multi-tenant applications.

The choice of data isolation approach depends on factors like security requirements, customization needs, scalability goals, and budget.

2. Resource Management:

This refers to how the shared resources (compute, storage, network etc) are allocated and managed among tenants in a Multi-tenant architecture.

We discussed about the noisy neighbor problem earlier which is one of the challenges of resource management in Multi-tenancy where one tenant's heavy usage can impact the performance of other tenants.

To address this, resources need to be managed effectively and allocated based on tenant requirements and usage patterns. Once this is achieved, it leads to better performance, cost and operational efficiency, and scalability of the application.

Real world examples 🌐

Multi-tenancy is widely used in various domains like Project Management, CRM, Content Management, LMS etc. It's used by many popular SaaS applications like:

• Slack: Multiple organizations use the same Slack application while keeping their data isolated.
• Shopify: Multiple merchants use the same Shopify platform to manage their online stores.
• HubSpot: Multiple businesses use the same HubSpot CRM platform to manage their customer relationships.

Multi Tenancy in Next.js 🚀

Next.js is a popular React framework that can be used to build Multi-tenant applications.

It facilitates this by the custom subdomain routing along with using middleware to handle tenant-specific logic.

Check out this video by Lee Robinson implementing Multi-tenancy in Next.js:

Multi-Tenant SaaS in Next.js

Multi-tenancy Demo

Github

TL;DR

• Multi-tenancy is an architecture where multiple tenants/users/organization share the same underlying application instance while keeping their data logically separated.
• It provides cost efficiency, effective resource utilization, and ease of maintenance.
• Challenges include data isolation, security concerns, customization limitations, and resource management.
• Various approaches to routing tenants include Subdomain Routing and Path-based Routing, each with its own pros and cons.
• Next.js can be used to build Multi-tenant applications using custom subdomain routing and middleware.