DEV Community: Anik Saha

Understanding Multi-Tenant Architecture (Part-One)

Anik Saha — Thu, 08 May 2025 13:46:09 +0000

Multi-tenant architecture is a powerful concept in software development, especially in SaaS (Software as a Service) platforms. If you're just starting out in backend or full-stack development, understanding how multi-tenancy works is essential.

What is Multi-Tenant Architecture?

In simple terms, multi-tenancy means that a single instance of your software runs on a server and serves multiple customers (called "tenants"). Each tenant’s data is isolated, but they all use the same application.
Think of it like a single apartment building where multiple families live. Each family has their own apartment (data and settings), but the building (application) is shared.

Types of Multi-Tenant Architectures:

1. Shared Database, Shared Schema

All tenants share one database and one set of tables.
Tenant data is separated using a tenant_id column in each table.

2. Shared Database, Separate Schemas

All tenants use the same database, but each tenant has its own set of tables (schemas).

3. Separate Databases

Each tenant has its own database.
Offers better isolation and security, but can be harder to manage at scale.

Each tenant can have its own database or share the same one depending on your architecture choice.

Key Benefits:

Cost-Efficient: One app serves multiple users.
Scalable: Easily add more tenants.
Centralized Management: Easier to update and patch.

Challenges:

Data Isolation: Must ensure no tenant can access another's data.
Complex Migrations: Updating schemas across tenants is tricky.
Security: More tenants = higher security responsibility.

** Best Practices**

Always use tenant-specific identifiers (tenant_id).
Design for scalability from the start.
Monitor tenant performance individually.
Secure your APIs and data access.

Final Thoughts:

Multi-tenant architecture is the backbone of scalable SaaS platforms. Whether you go for shared schemas or separate databases, the goal is to balance cost, security, and scalability.
If you’re planning to build a SaaS product, learning this basic concept and start development.

Postman new update that developer should know

Anik Saha — Thu, 16 May 2024 03:40:11 +0000

What is Postman?

Postman is an API platform for building and using APIs. Postman simplifies each step of the API lifecycle and streamlines collaboration so you can create better APIs—faster.

New updates :

Store and reuse scripts everywhere with the package library
Available on Free, Basic, Professional, and Enterprise plans

With the new Package Library, teams can now store and reuse test scripts for more efficient and reliable API testing. Test script packages can contain business logic and code, which can be consumed in multiple requests by just referencing the package in various places within the team. Change once, use everywhere. No more copy-pasting. No more redundant code.
**
Package Library: **

Configure request and collection runs using the Postman Runtime library. The library is an open-source Node.js project you can use for low-level configuration over request sending in your API development and testing projects.

runtime = require('postman-runtime');
var runner = new runtime.Runner();

var collection = new sdk.Collection();

runner.run(collection, {
  data: [],
  timeout: {
    request: 30000,
    script: 5000
  },
  iterationCount: 1,

  //other options...

},
function (err, run) {
  //Callbacks to execute as the collection runs
  run.start(callbacks);
});

You can use the Runtime library if you need a detailed configuration of your request runs, for example as part of an automation workflow to integrate Postman Collection runs into your development pipeline.

How to optimize SQL queries

Anik Saha — Fri, 29 Mar 2024 12:46:26 +0000

With so many companies using the cloud to store large amounts of data, SQL optimization has become more important than ever. SQL (structured language query) is a programming language used to query and communicate with a database to extrapolate information. It is a language that can be used to perform a variety of tasks, such as creating, querying, updating, and deleting data. The performance of SQL queries greatly depending on how to the query written.

This guide will discuss some of the most important factors to consider when optimizing SQL queries.

Why Optimize SQL Queries?
Imagine a customer searching for a product in online and results take a few minutes a appear. What do you think customer wait? In my opinion probably not. For this reason Database managers must ensure SQL queries optimize with efficiency.

1. Use indexes efficient
Indexes are a key to query performance. They allow the database to quickly find the rows that match your query criteria.

2. Avoid SELECT queries
SELECT queries are inefficient. This is because they view all the fields in a dataset rather than just the relevant ones. Instead, focus on retrieving necessary columns only. By only selecting the fields that you need to view, models and reports will be clean and easier to use.

3. Use Joins Properly
Joins can be a powerful tool, but they can also be costly. Choose the right join type for the task at hand, and use efficient join conditions to avoid cartesian products.

4. Use EXIST() instead of COUNT() queries
When searching for a specific element in a table, it’s more efficient to use an EXIST() keyword instead of a COUNT() one. This is because a COUNT query counts every instance of the specific search element – which can be very inefficient, especially if the database is large!

5.Avoid subqueries
When subqueries are used in WHERE or HAVING clauses, they can slow down the performance of the query. This is because they can return large numbers of rows, making them difficult to execute.

6. Use Caching and Materialized Views
Caching and materialized views can be used to store frequently accessed query results in memory, which can significantly improve performance.

7.Use Tools for Query Tuning
There are number of tools available like APEXSQL Plan, SQL Azure Query Performance Insight that can help you to understand how your queries are executing, and EXPLAIN and ANALYZE commands can help you to identify optimization opportunities.

Conclusion

Understanding and monitoring performance plays a key role in optimizing SQL queries and combined with simple steps such as indexing and swapping functions you can quickly make a difference to search time.

When to Use React Query or useEffect for Data Fetching

Anik Saha — Sun, 25 Feb 2024 11:43:26 +0000

When it comes to data fetching in React Applications all developers often face a dilemma what should we use to React Query or traditional useEffect hooks?

Two commonly used tools for these purposes are React Query and useEffect. But both approaches have their own strengths and weaknesses.

In this blog, we will explore how and when two approaches are used and why.

Using React Query for Data Fetching

React Query is a powerful library designed specifically for fetching, caching, synchronizing, and updating server state in React applications. It offers a declarative API and integrates seamlessly with React components.

Key Features:

Declarative Data Fetching:** React Query provides a declarative approach to data fetching, making it easy to fetch and manage data in React components.

2. Caching: It automatically caches fetched data, optimizing performance by reducing unnecessary network requests.

3. Automatic Data Refetching: React Query can automatically refetch data based on various triggers such as stale time, window focus, or specific actions.

4. Mutation Management: It simplifies managing mutations (e.g., POST, PUT, DELETE requests) and provides built-in support for optimistic updates and error handling.

Example:

import { useQuery } from 'react-query';

async function fetchUsers() {
  const response = await fetch('/anik/v1/data');
  if (!response.ok) {
    throw new Error('Network response was not ok');
  }
  return response.json();
}

function UsersList() {
  const { isLoading, error, data } = useQuery('users', fetchUsers);

  if (isLoading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <ul>
      {data.map(user => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}

export default UsersList;

Using useEffect for Data Fetching

useEffect is a built-in React hook used for handling side effects in functional components. It allows you to perform operations such as data fetching, subscriptions, or DOM manipulations after component renders.

Key Features:

1. Lifecycle Management: useEffect provides a way to perform 2 side effects in functional components similar to lifecycle methods in class components.

2. Dependency Tracking: It enables you to specify dependencies, ensuring that the effect runs only when certain values change.

3. Cleanup: You can return a cleanup function from useEffect, which executes when the component unmounts or before the effect runs again.

4. Custom Hooks: useEffect can be used to create custom hooks for encapsulating logic and reusing it across components.

Example Code:

import React, { useState, useEffect } from 'react';

function UsersList() {
  const [users, setUsers] = useState([]);

  useEffect(() => {
    const fetchUsers = async () => {
      try {
        const response = await fetch('/anik/v1/data');
        if (!response.ok) {
          throw new Error('Network response was not ok');
        }
        const data = await response.json();
        setUsers(data);
      } catch (error) {
        console.error('Error fetching users:', error);
        // You can handle errors here, e.g., set an error state
      }
    };

    fetchUsers();
  }, []); // Empty dependency array ensures the effect runs only once

  return (
    <ul>
      {users.map(user => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}

export default UsersList;

Conclusion:

Both React Query and useEffect serve distinct purposes in React development. React Query is ideal for managing complex data fetching scenarios with built-in caching and mutation management, while useEffect is suitable for basic data fetching and other side effects within functional components. Understanding the strengths and use cases of each tool empowers developers to make informed decisions when architecting React applications.

ReactJs Virtual DOM

Anik Saha — Wed, 19 Jul 2023 20:16:05 +0000

What is DOM? And why we are understanding react DOM?

DOM stands for 'Document Object Model'. It is a structured representation of HTML in the webpage or application . In modern javascript framework have change the way of web development.They have provided a great abstraction by addressing common issues in browsers and enhancing performance using methodologies that were not possible through plain JavaScript.

One of the most popular javascript framework of front-end development is React js.

What is react dom? How it is work?

React popularized something called the Virtual DOM.The virtual DOM is only a virtual representation of the actual DOM.For every DOM object, there is a corresponding Virtual DOM object. Everytime the state of our application changes, the virtual DOM gets updated instead of the real DOM.
ReactDOM is a package that provides DOM-specific methods that can be used at the top level of a web app to enable an efficient way of managing DOM elements of the web page. ReactDOM provides the developers with an API containing the following methods and a few more.

-render()
-findDOMNode()
- unmountComponentAtNode()
- hydrate()
- createPortal()

How does a page render in a browser?

When a browser loads any webpage, the page is loaded in multiple parts, then it is constructed in the browser and rendered.

The HTTP protocol returns data in bytes.
These bytes are converted into characters, then tokens, then nodes, and then, lastly, the object model.
The DOM (Document Object Model) is a tree-like structure that represents HTML. It is generated from a webpage’s HTML markup. Similarly, the CSSOM (CSS Object Model) is generated from a webpage’s CSS markup. The DOM and CSSOM are loaded independently as trees, and then they are combined into a render tree to form a webpage.

Why is React so fast?

There is no direct access or change to the DOM elements in Virtual DOM. When virtual DOM gets updated, React compares it with a virtual DOM snapshot that was taken right before the update. It then compares the new virtual DOM with the previous virtual DOM and figures out which objects have changed.
Once React knows which virtual DOM objects have changed, it updates only those objects on the real DOM and other elements don't get updated as opposed to what the real DOM normally does. This is how virtual DOM works behind the scenes, making it much faster.

Conclusion

Virtual DOM is a powerful concept that React uses to overcome standard performance issues in the browser.

JavaScript Loops

Anik Saha — Fri, 26 Aug 2022 08:23:53 +0000

Hello everyone, welcome to the third blog of the beginner series.
In previous blog we talked about data type method, today we will be discussing basics on loops.

What is loop?

Loop is a sequence of instruction that is continuously repeated until a certain condition is reached.

Types of loops :

There are three types of loops, "while loops", "for loops", "do-while loop".

**while Loops:

**
while loops continue to run until a condition is true.

Syntax :

The purpose of a while loop is to execute a statement or code block continuously repeated as long as an expression is true. Once the expression became false, the loop terminates.

Output:

do-while Loop:

do-while loop is similar to the while loop except that the condition check happens at the end of the loop.

Syntax:

If the condition is true the loop will repeated. Or loop will always be executed at least once , even if the condition is false.

Since the do block is run first without checking the condition, this can cause unexpected issues if you're not careful.

For Loop:

for loop are the most common type of loop. for loop repeats until a specific condition evaluates to false.

The initial expression , if any is executed. This expression usually initialize one or more loop.
The condition Expression is ending of the loop. If the expression is true , the loop statements execute.
To execute multiple statements use block statement.

Here the example of for loops. The most common loop -

Output:

Ending Notes

This is all about loops, thanks for your reading till the end.

You will also check this link :
https://www.w3schools.com/js/

JavaScript (ES6) data Type

Anik Saha — Wed, 17 Aug 2022 09:30:00 +0000

Hello everyone, welcome to the second blog of the beginner series.
In previous blog we talked about DOM method, today we will be discussing basics on Data types.
**

what is data type?
**
Data type describe the different types or kinds of data that we are gonna be working with and how things are stored. In javascript, there are 6 data types:

String type
Boolean type.
Null type.
Undefined type.
BigInt type.
Symbol type **

String:

**
A string is a series of characters like "Harry". Also it could be a single character, a line of text, a paragraph, and so on. In javaScript there is no difference between single quotes and double quotes. You can use quotes inside a string, as long as they don't match the quotes surrounding the string.

Boolean Type:

**
In programming there is only two type of values, like

True or False
yes or No.

Null type :

**
JavaScript Null value represent the international absence of any object value.

Undefined type:

**
A variable without a value defined has the value undefined. This is not similar as Null.

BigInt type :

**
BigInt is a built-in object in javaScript. It's a primitive wrapper object used to represent and manipulate primitive BigInt values which are too large to be represented by the number primitive.

Symbol type :

**
A symbol represents a unique identifier. we can create many symbols with the exactly the same description, but they are different values. Symbols are must be unique.

Ending Notes

This is all about Data Types, thanks for your reading till the end.
You will also check this link :
https://www.w3schools.com/js/

JavaScript DOM

Anik Saha — Fri, 29 Jul 2022 12:04:00 +0000

Introduction

JavaScript DOM(Document Object Model) is essential part of web development. DOM is a platform that allows programs and script to dynamically access and content , style and structure of a document.
There are three different parts of DOM -
a. Core DOM - Document type
b. XML DOM - XML Documents
c. HTML DOM - HTML documents
In these case we will discuss about HTML DOM.

1) document.getElementById:
Select element using get element by Id .

2) document.querySelector :
select element using query selector.

3) document.getElementByTagName:
Select element by tag name .

4) document.getElementByClassName:
Get multiple elements using getElements by class name.

5) document.querySelectorAll:
Get multiple elements items using querySelectorAll.

Event listeners in DOM

The addEventListener() method allows you to add event listeners on any HTML DOM object such as HTML elements, the HTML document, the window object.

click event ()

The onclick event occurs when the user clicks on an element.

addEventListener() method, the JavaScript is separated from the HTML markup, for better readability and allows you to add event listeners even when you do not control the HTML markup.

when user click on change color button the body background will automatically change and the color of text will change also.