Don’t worry.
This concept is actually very simple.

In this blog, we’ll understand:

• What multi-tenancy really means

• Why is it used in real applications

• How big companies use it

• Different ways to implement it

• Pros and cons of each approach

What is Multi-Tenancy?

Multi-tenancy means:

One application serving many customers at the same time — safely and separately.

Each customer is called a tenant.

All tenants:

• Use the same application

• Run on the same infrastructure

• Share the same code

But still:

• Their data is completely private

• One tenant can never see another tenant’s data

That’s the most important rule of multi-tenancy.

A Simple Real-Life Example (Apartment Building)

Imagine an apartment building 🏢

• The building = the application

• Each flat/apartment = one tenant

Everyone in the building:

• Uses the same lift

• Uses the same water supply

• Uses the same electricity system

But still:

• You cannot enter someone else’s flat

• Your personal things stay private

• Your neighbour cannot see what’s inside your home

This is exactly how multi-tenancy works in software.

Shared system, but private spaces.

Why Do We Need Multi-Tenancy?

Imagine if every customer needed:

• A separate application

• Separate servers

• Separate codebase

That would be:

• Very expensive

• Hard to maintain

• Impossible to scale

Multi-tenancy solves this problem by:

• Sharing resources

• Reducing cost

• Making systems scalable

• Allowing thousands or millions of users

That’s why almost every modern SaaS product uses multi-tenancy.

Real-World Examples of Multi-Tenancy

Let’s look at some apps you already know.

🛒 Shopify

Thousands of businesses create their online stores using Shopify.

• All stores run on the same Shopify platform

• Same backend code

• Same servers

But:

• One store cannot see another store’s customers

• Products, orders, and payments are fully isolated

Each store = one tenant.

💻 GitHub

GitHub uses organizations.

• One organization = one tenant

• Repositories are isolated per organization

• Permissions are scoped correctly

This is multi-tenancy in action.

How is Multi-Tenancy Implemented?

There are two common ways to build multi-tenant systems.

Each has its own advantages and disadvantages.

Approach 1: Separate Database for Each Tenant

How It Works

• Every tenant gets its own database

• If you have:

  • 10 customers → 10 databases

  • 1 million customers → 1 million databases

Each database is completely independent.

Why This is Good

✅ Very strong data isolation
✅ Almost zero chance of data leakage
✅ Easy to reason about security
✅ Simple queries (no filtering needed)

Why This is Problematic

❌ Hard to manage at a large scale
❌ Creating and maintaining databases is expensive
❌ Small tenants waste resources
❌ Deployment and migrations become complex

This approach is usually used when:

• Security is extremely critical

• The number of tenants is limited

• Each tenant is large.

Approach 2: Shared Database with Tenant ID (Row-Level Separation)

How It Works

• All tenants share one database

• Every table has a tenant_id column

• Each row belongs to one tenant

Example:

When a tenant makes a request:

• System fetches only rows with that tenant’s ID

Why This is Good

✅ Very easy to scale
✅ Only one database to manage
✅ New tenant = just new rows
✅ Better resource utilization

This is the most common approach in SaaS apps.

Why This is Risky

❌ One small bug can leak data
❌ Every query must be written carefully
❌ Missing tenant filter = security issue
❌ Requires strong testing and discipline

This approach works best when:

• You have many tenants

• You want fast onboarding

• Your engineering practices are strong

Which Approach Should You Choose?

There is no single correct answer.

It depends on:

• Number of tenants

• Size of each tenant

• Security requirements

• Cost constraints

• Engineering maturity

Many companies even use hybrid approaches:

• Small tenants → shared database

• Large tenants → separate databases

Why Every Developer Should Understand Multi-Tenancy

If you want to build:

• SaaS products

• Scalable backends

• Real-world applications

Then, multi-tenancy is not optional knowledge.

It teaches you:

• Data isolation

• Security thinking

• Scalable design

• Real production problems

As a developer, you probably build the frontend app or web app using basic Technology like HTML, CSS, Javascript, and React (Javascript library) you can easily deploy them using famous platforms like Vercel, Netlify, and many more. but in the case of deploying the backend server is like a snowball's chance in Hell.

If you know some Backend then you might use express to create the Backend server and run it usually node index.js which starts a process on a certain port whatever you defined.

If you want to deploy it on the internet, there are a few ways-

i. AWS ii. GCP [Google Cloud Platform Services] iii.Azure iv. Cloudflare

HOW?

1. Rent a VM (Virtual Machine) and deploy your app.

2. Put it in an Auto-scaling group

3. Deploy it in a Kubernetes cluster

Don't worry if don't get any idea about these we will discuss everything further.

Everything and Everyone has pros and cons similar to the downside of this is-

1. Taking Care of how/when to scale.

2. You have to pay the base cost even if no one is visiting your website

3. Monitoring various servers to make sure no server is down

What if, you could just write the code and someone else could take care of all of these problems?

What areserverless Backends

Definition:

What if you could just write your express routes and run a command. The app would automatically

1. Deploy

2. Autoscale

3. Charge you on a per request basis (rather than you paying for VMs)

As I told you everything in this world has pros and cons so this also has some cons but these cons or problems are very important to know.

1. More Expensive at scale: -

As the backend system grows bigger, it costs more money to manage and maintain it properly.

2. Cold start problem: -

"Delayed response when serverless function or microservice is inactive or newly initialized."

There are many famous backend serverless providers -

https://aws.amazon.com/pm/lambda/?trk=5cc83e4b-8a6e-4976-92ff-7a6198f2fe76&sc_channel=ps&ef_id=CjwKCAiAt5euBhB9EiwAdkXWO-i-th4J3onX9ji-tPt_JmsBAQJLWYN4hzTF0Zxb084EkUBxSCK5vhoC-1wQAvD_BwE:G:s&s_kwcid=AL!4422!3!651612776783!e!!g!!aws lambda!19828229697!143940519541

https://firebase.google.com/docs/functions

https://workers.cloudflare.com/

But we will use Cloud-flare for this :

Just go on the Cloudflare website and sign up if you are new you will get to see something like this. before we proceed there is a big question that arises which is:-

When should you use a serverless architecture?

1. When you want Quick Launch:

   • Serverless lets you start your app fast without server setup worries. It's like moving into a ready-to-use office.

2. When you want Automatic Scaling:

   • It adjusts to traffic changes automatically. Think of it as a store that expands or shrinks based on customers, saving costs.

3. When you want Cost Optimization:

   • You pay only when your code runs, making it cost-effective for low-traffic apps. It's like paying for electricity only when you use it, keeping bills low.

Few senior developers want to know how Cloudflare workers work.

For detailed blog post click here:- Blog on Workers

they can read this blog for more detail i also mentioned some important glimpses from the blog:

I think You know enough to start using Cloudflare. Don't worry, just follow my steps carefully, and you'll learn how to set up the backend without any problems.

• Create a directory with a name whatever you want suppose we created a directory with name practice.

• Open this directory in the code Editor whatever you use

• Open the terminal in the code editor and write this command for initializing the Cloudflare init the command is:-

  COPY

  COPY

       npm create cloudflare
  

now select the "Hello World" workers as we just Learning.

As I know the typescript I preferred to use typescript. if you don't then relax there is not to worry

After that, they ask you:

• Do you want to deploy your application? Select the NO because we will deploy the backend using npm run deploy

• Explore package.json dependencies

  COPY

  COPY

      "wrangler": "^3.0.0"
  

  Notice express there is no dependency on there

• Start the worker locally and write this in the directory where package.json exists

  COPY

  COPY

      npm run dev
  

  After that, your terminal will look like this now just press ctrl and on the localhost:8787:-

  

  You can see you are directed to the browser where Hello World is written.

• Open src file you'll see this:

• 

  Question - Where is the express code? HTTP Server?

  Cloudflare expects you to just write the logic to handle a request. Creating an HTTP server on top is handled by Cloudflare

• Question - How can I dorouting ?

  In express, routing is done as follows -

  COPY

  COPY

      import express from "express"
      const app = express();
  
      app.get("/route", (req, res) => {
          // handles a get request to /route
      });
  

  This is how you can do the same in the Cloudflare environment.

  COPY

  COPY

      export default {
          async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
              console.log(request.body);
              console.log(request.headers);
  
              if (request.method === "GET") {
                  return Response.json({
                      message: "you sent a get request"
                  });
              } else {
                  return Response.json({
                      message: "you did not send a get request"
                  });
              }
          },
      };
  

  Don't worry if you see this code; it's just for reading purposes. We won't use it. This code shows how to create a GET request using Cloudflare Workers, but we won't use it because Cloudflare Workers use their library, not Node.js or any other common libraries. Writing code with this library can be challenging.

• Lets Deploying a worker

Now that you have written a basic HTTP server, let’s get to the most interesting bit — Deploying it on the internet

We use Wrangler Dont worry I'll tell you

Step 1 Log in to Cloudflare via the Command Line Interface npx wrangler login Nothing just type this in the terminal of the code editor where the project is going on.

you'll see something like this.

Step 2 Deploy Your Worker:

COPY

COPY

npm run deploy

After this, you'll see something like this

This is optional and just to know:-

Assigning a custom domain

You have to buy a plan to be able to do this

You also need to buy the domain on Cloudflare/transfer the domain to Cloudflare

Come back to the topic If you now go back to the website it will show you this means that u deployed your application for now ignore my-app the app we deploy is calm-sun-10b3

• Now come back to the very important question which is whether we always use this challenging worker syntax or we have something else to tackle this problem.

Why can’t we use express?

Now you might be thinking Why does Cloudflare doesn’t start with a simple express boilerplate? the answer to this Question is very simple:

• Express heavily relies on Node.js

The answer to this big question is:

Using Hono

You must read this Because this will give you the answer to all the questions you have in your mind:-

What runtime does it support:

Using Hono is easy:-

Initialize a new app

COPY

COPY

npm create hono@latest my-app

1. Move to my-app and install the dependencies.

COPY

COPY

cd my-app
npm i

1. Hello World

COPY

COPY

import { Hono } from 'hono'
const app = new Hono()

app.get('/', (c) => c.text('Hello Cloudflare Workers!'))

export default app

Getting inputs from the user

COPY

COPY

import { Hono } from 'hono'

const app = new Hono()

app.post('/', async (c) => {
  const body = await c.req.json()
  console.log(body);
  console.log(c.req.header("Authorization"));
  console.log(c.req.query("param"));

  return c.text('Hello Hono!')
})

export default app

If you are here and learning the serverless Backend so you know what is Postman and how to use it now just do one thing.

• Go on the Postman and write the localhost(URL) above

• Select the POST from the options

• Write any value in the headers with the key Authorization and query param.

• Now click on the Send Button.

• You can see the output in the console if there is an error try to fix it.

Deploying

Make sure you’re logged into Cloudflare (wrangler login)

COPY

COPY

npm run deploy

Middlewares

Creating a simple auth middleware

Middleware is very important in the backend this is how you define the middleware in the backend.

COPY

COPY

import { Hono, Next } from 'hono'
import { Context } from 'hono/jsx';

const app = new Hono()

app.use(async (c, next) => {
  if (c.req.header("Authorization")) {
    // Do validation
    await next()
  } else {
    return c.text("You dont have acces");
  }
})

app.get('/', async (c) => {
  const body = await c.req.parseBody()
  console.log(body);
  console.log(c.req.header("Authorization"));
  console.log(c.req.query("param"));

  return c.json({msg: "as"})
})

export default app

Notice you have to return the c.text value.

"As you can see, coding in Hono is quite similar to using Express. Hono is an excellent library for writing code in Cloudflare Workers and deploying the backend. That wraps up this blog. Thank you for reading!".

Most students prefer to learn SQL databases after they learn the NoSQL like MongoDB which is good to learn NoSQL database which is a very good approach but if it's your first time learning database it's alright I am here to explain you each and everything you have to know about.

but before let's see what is the difference between the SQL and NoSQL databases.

• NoSQL databases

1. Store data in a schema-less fashion. Extremely lean and fast way to store data.

2. Examples - MongoDB,

SQL databases

1. Stores data in the form of rows

2. Most full-stack applications will use this

3. Examples - MySQL and, Postgres

but you see what is wrong with the NoSQL database and why most of the full stack app uses the SQL database

Why not NoSQL?

its schemaless property makes it ideal for bootstrapping the project fast,
But as your app grows, this property makes it very easy for data to get curropted

What is Schemaless?

Different rows can have different schema (keys/types)

**

Problems?**

1. This can lead to inconsistent database

2. Can cause runtime errors

3. Is too flexible for an app that needs strictness

Upsides?

1. Can move very fast

2. Can change schema very easily

There is a point above Is too flexible for an app that needs strictness this principle is also applicable in real life and in the coding for that we are using typescript instead of javascript. My blog on the typescript is coming on 10 March 2024 on my blog channel. let's come back to the topic.

till now we have discussed how many types of databases and what is the problem with NoSQL, let me discuss solid reasons for :

Why SQL?

SQL databases have a strict schema. They require you to

1. Define your schema

2. Put in data that follows that schema

3. Update the schema as your app changes and perform migrations

if you already know the NoSQL database then you can easily understand the points that are given below:

So there are 4 parts when using an SQL database (not connecting it to Node.js, just running it and putting data in it)

1. Running the database.

2. Using a library that lets you connect and put data in it.

3. Creating a table and defining it’s schema.

4. Run queries on the database to interact with the data (Insert/Update/Delete)

if you don't know about them then don't worry we just do in the second point we said that

we are gonna use a library to perform the CRUD operation in the SQL database if you don't know what is CRUD then it simply means Create Read Update and Delete. from the database.

Okay I think this is enough to explain the SQL so let's move to

Creating a database

You can go and easily generate the Postgres string for the database from neon db for now I am going to do it locally by using docker no need to install Postgres locally because it takes time and data for this practice session and learning session I am going to generate the Postgres string using Docker so let's get start:

• Using docker locally

if you also have docker locally then follow this command in your terminal for generating the container of postgres locally.

docker run --name my-postgres -e POSTGRES_PASSWORD=mysecretpassword -d -p 5432:5432 postgres

in this command POSTGRES_PASSWORD=mysecretpassword you can write any password you want to secure your database. it depends upon you.

Connection String

Now modify the connecting string as per your password and your string is ready which helps you to connect the database and your backend.

postgresql://postgres:mysecretpassword@localhost:5432/postgres?sslmode=disable

• Using neondb

https://neon.tech/ is a decent service that lets you create a server.

Connection String

Your connecting string will look like something this but the password and username will change as per your command

postgresql://username:password@ep-broken-frost-69135494.us-east-2.aws.neon.tech/calm-gobbler-41_db_2253874

Using a library that lets you connect and put data in it.

1. psql

psql is a terminal-based front-end to PostgreSQL. It provides an interactive command-line interface to the PostgreSQL (or TimescaleDB) database. With SQL, you can type in queries interactively, issue them to PostgreSQL, and see the query results.

How to connect to your database?

psql Comes bundled with Postgresql. You don’t need it for this tutorial. We will directly be communicating with the database from Node.js

psql -h p-broken-frost-69135494.us-east-2.aws.neon.tech -d database1 -U 100xdevs

2. pg

pg is a Node.js library that you can use in your backend app to store data in the Postgres DB (similar to mongoose). We will be installing this eventually in our app.

for now, just read them both if you are getting confused then don't worry we will discover them deeply in further blog for now lets:

Creating a table and defining it’sschema.

Tables in SQL

A single database can have multiple tables inside. Think of them as collections in a MongoDB database.

Until now we just have just database that we can interact with. The next step in the case of postgres is to define schema of your tables. To create a table, the command to run is -

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    password VARCHAR(255) NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

1. CREATE TABLE USER: this command initiates the creation of a new table in the database named user.

2. id SERIAL PRIMARY KEY:

   • id: The name of the first column in the users table.

   • SERIAL: A PostgreSQL-specific data type for creating an auto-incrementing integer.

   • PRIMARY KEY: This constraint specifies that the id column is the primary key for the table, meaning it uniquely identifies each row. Values in this column must be unique and not null.

3. email VARCHAR(255) UNIQUE NOT NULL:

   • email: The name of the second column, intended to store the user's username.

   • VARCHAR(50): A variable character string data type that can store up to 50 characters.

   • UNIQUE: No two users can have the same username.

   • NOT NULL: every row must have a username.

4. reated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP

   • created_at: The name of the fifth column.

   • TIMESTAMP WITH TIME ZONE: This data type stores both a timestamp and a time zone.

Don't lose hope of learning Postgres this is just for the reading I know this is tough but you have to just read this and that's it. you don't have to learn this. I have a better and easier version for you. Which is PRISMA we will discuss this in PART-2 of this blog for now let's move ahead

💡

If you have access to a database right now, try running this command to create a simple table in there

• Then try running \dt; to see if the table has been created or not

if you still don't understand let me explain to you briefly okay so:

Step 1: Install Docker

You have to install the docker locally by watching YouTube because this is the better way to use Postgres instead of using it online ok let's start after installing the docker locally your docker will look like this

after downloading you do not have to signin or signup you have to just start the docker using the terminal open the terminal and type

sudo systemctl start docker

after that, your docker gets started and you have to just open the terminal and run the command given below but before that, you can use whatever the password you want for your database in place of the mypassword POSTGRES_PASSWORD=mysecretpassword

docker run --name my-postgres -e POSTGRES_PASSWORD=mysecretpassword -d -p 5432:5432 postgres

after running this command you see something like this:

you can see after running the command the instance of the postgres created in the docker now running. Now your connecting string is ready to use which is

postgresql://postgres:mysecretpassword@localhost:5432/postgres?sslmode=disable

use your password instead of mypassword;

Step 2: Creating the user table:

open the new Terminal and run the docker ps command it will show you how many containers are there in the docker, now copy the containerID from it

now we are going to open the terminal of the container for that we have to follow the command

docker exec -it CONTAINER ID psql -U postgres

write the container ID correctly now welcome to the Postgres terminal in the container which looks like

now we have nothing in this so first we have to create the user table To create the user table we will follow these commands:

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    password VARCHAR(255) NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

I already explained this above so I have to proceed after running this command in your terminal the user table gets created like this

this is how you can create the user table in postgres. Now it is time to insert the user in it for that we have another command:

• INSERT

INSERT INTO users (username, email, password)
VALUES ('username_here', 'user@example.com', 'user_password');

fill them according to your name email and password,

• UPDATE

UPDATE users
SET password = 'new_password'
WHERE email = 'user@example.com';

• DELETE

DELETE FROM users
WHERE id = 1;

• SELECT

SELECT * FROM users
WHERE id = 1;

To see the inserted user you have to use the command:

SELECT * FROM users;

this is how easy it is.

What about the Nodejs app how do Query from that?

psql is one such library that takes commands from your terminal and sends them over to the database.

To do the same in Node.js, you can use one of many Postgres clients

but before that :

npm i pg

Connecting: -

import { Client } from 'pg'

const client = new Client({
  host: 'my.database-server.com',
  port: 5334,
  database: 'database-name',
  user: 'database-user',
  password: 'secretpassword!!',
})

client.connect()

Querying -

const result = await client.query('SELECT * FROM USERS;')
console.log(result)

this is a function to create a user table in your database.

import { Client } from 'pg'

const client = new Client({
  connectionString: "postgresql://postgres:mysecretpassword@localhost/postgres"
})

async function createUsersTable() {
    await client.connect()
    const result = await client.query(`
        CREATE TABLE users (
            id SERIAL PRIMARY KEY,
            username VARCHAR(50) UNIQUE NOT NULL,
            email VARCHAR(255) UNIQUE NOT NULL,
            password VARCHAR(255) NOT NULL,
            created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
        );
    `)
    console.log(result)
}

createUsersTable();

Sure! Looking forward to Part 2 of the Database Blog series with Prisma. If you have any more questions or need assistance in the future, feel free to reach out. Goodbye for now!