Should we use SQL or NoSQL?

Let’s break this down in plain English.

First, what is a database?

A database is where your product stores data, including users, orders, payments, events, messages, logs, and more.

The two broad types you’ll hear engineers talk about are:

• SQL databases

• NoSQL databases

What is SQL?

SQL stands for Structured Query Language.

How SQL databases think

• Data is stored in tables

• Tables have fixed columns

• Relationships between tables are clearly defined

Think of SQL like an Excel sheet with rules.

Example (SQL-style data)

User Table

| user_id | name  | email                                     |
| ------- | ----- | ----------------------------------------- |
| 1       | Rahul | [rahul@gmail.com](mailto:rahul@gmail.com) |
| 2       | Anita | [anita@gmail.com](mailto:anita@gmail.com) |

Order Table

| order_id | user_id | amount |
| -------  | -----   | -------|
| 2314     | 1       | 999    |
| 2315     | 2       | 432    |

Here, user_id connects users and orders.

Key characteristics of SQL

• Fixed schema (structure decided upfront).

• Strong data consistency.

• Great for complex queries and reporting.

What is NoSQL?

NoSQL stands for Not Only SQL.

How NoSQL databases think

• Data is stored in flexible formats

• No fixed schema

• Each record can look different

Think of NoSQL like Google Docs, flexible and fast.

Example (NoSQL-style data)

{
  "user_id": 1,
  "name": "Rahul",
  "email": "rahul@gmail.com",
  "orders": [
    { "order_id": 2314, "amount": 999 },
    { "order_id": 2315, "amount": 439 }
  ]
}

Another user might have different fields altogether.

Key characteristics of NoSQL

• Schema-less or flexible schema.

• Highly scalable.

• Optimized for speed and large volumes.

When should a Product Manager choose SQL?

Choose SQL when:

✔ Data structure is clear and stable
✔ Relationships matter (users → orders → payments)
✔ Accuracy is critical (finance, billing, inventory)
✔ You need analytics & reporting

Product example

Payment, Insurance, Banking, ERP systems

If an order is paid, it must be recorded correctly in a structured way, no compromise.

👉 SQL shines here.

When should a Product Manager choose NoSQL?

Choose NoSQL when:

✔ Data structure changes frequently
✔ Scale is unpredictable or massive
✔ You need very fast reads/writes
✔ Data doesn’t need complex joins

Product example

Chat apps, activity feeds, logs, analytics events

A WhatsApp message or user activity log doesn’t require a strict structure; speed is more important.

👉 NoSQL wins here.

A Real Product Scenario (Hybrid Approach)

Most modern products use both.

Example: E-commerce app

• SQL → Users, orders, payments, refunds

• NoSQL → Search history, product views, clickstream events

As a PM, this helps you:

• Ask better questions.

• Understand trade-offs.

• Align tech decisions with business goals.

API is a software intermediary that allows different applications to communicate and share data. In simple words, An API acts as a middleman, receiving requests from the client, processing them with the backend, and returning the results to the client.

The API (Application Programming Interface) lifecycle encompasses several stages through which an API goes from conception to retirement. Here’s a breakdown of the key stages with explanations and examples to help make it easier for a fresher to understand:

1. Planning Phase: In this phase, the stakeholders (business owners, product managers, and developers) come together to identify the need for the API. They gather requirements by considering potential users and the use cases.

Example:

Stakeholders may want to build an API that gives access to real-time weather data and 7-day forecasts. They identify target users such as mobile app developers, web developers, and data analysts.

2. Design Phase: This stage involves creating a detailed API specification which includes the decision on the API Protocol like REST or SOAP, API End Points with Query Parameters if any, Final URL, API Method (GET, DELETE, PATCH, or POST), Headers, Request and Response Body, and Authentication.

Example:

API Format can be JSON or XML.

API endpoint: /weather/current?location={city} with full URL as /https://api.tusharchopra.com/v1//weather/current?location={city}

In this example, GET is the HTTP method to fetch the current weather of a city and the response would be

JSON Response Example for Current Weather:

{
  "location": "San Francisco, CA",
  "temperature": "68°F",
  "condition": "Cloudy",
  "humidity": "78%"
}

3. Development Phase: Developers build the API according to the design specifications. This includes writing backend logic to handle requests, integrating with databases or third-party weather data providers, implementing security protocols to avoid unauthorized access and attacks, and finally returning the data in a specific format.

4. Testing Phase: It ensures that the API behaves as expected. Testing includes not just functional testing but also error handling and load testing.

Example:

Test scripts validate that GET /api/v1/weather/current?location=San Francisco returns a successful response with the correct data structure and handles erroneous requests like GET /api/v1/weather/current?location= gracefully by returning a meaningful error message:

{

"error": "Location parameter is required"

}

5. Deployment Phase: Once testing is complete, the API is deployed to a production environment where developers and applications can access it.

6. Monitoring Phase: After deployment, monitoring is critical to ensure the API remains functional, performs well, and meets user expectations. It tracks usage patterns, error rates, and response times.

Example:

Setting up logging (using tools like ELK stack) and monitoring services (like Grafana, New Relic, or Datadog). Gathering usage data to see which endpoints are most popular and how users interact with the API.

7. Maintenance Phase: APIs require ongoing maintenance to fix bugs, improve performance, and update functionality based on user feedback. Regular updates ensure the API stays relevant and continues to meet user needs.

8. Versioning: As the API evolves, versioning helps maintain backward compatibility. When new features are introduced or existing ones are modified, updating the version number ensures that existing integrations remain unaffected.

9. Deprecation and Retirement: Eventually, some APIs may become outdated or replaced by better alternatives. To retire an API gracefully, communication with users is critical, providing them with opportunities to migrate to newer versions or APIs.

Product management involves steering your product in the right direction quickly. Data is a crucial component of decision-making, and conducting primary analysis yourself can significantly enhance your efficiency as a product manager.

Given that relational databases are still the most common types of databases, learning SQL (Structured Query Language) becomes crucial for PMs.

Relational databases such as MySQL, PostgreSQL, Oracle, and SQL Server are extensively used across industries. These databases store and manage vast amounts of critical data. Since SQL is the standard language for interacting with these databases, understanding SQL is essential for accessing and manipulating this data.

Why Should Product Managers Learn SQL?

1. They can independently query databases without constantly relying on data analysts or engineers, speeding up the process of data retrieval.

2. Understanding SQL enables better communication with data engineers, analysts, and developers, ensuring clear and precise data requirements.

3. Working knowledge of SQL helps PMs comprehend the limitations and possibilities of data retrieval, leading to more realistic expectations and effective collaboration.

SQL for Product Managers

While SQL allows you to read, insert, update, or delete data in relational databases, as a product manager, your primary focus will be on reading data as read queries in SQL will help you extract valuable data from relational databases.

Here are some of the most common read queries, along with examples:

1. SELECT Query

SELECT * 
FROM table_name;

SELECT * 
FROM users;

This query retrieves all columns and rows from the users table.

2. SELECT Specific Columns

You can specify which columns to retrieve by listing them after the SELECT keyword.

SELECT column1, column2, ...
FROM table_name;

SELECT first_name, last_name, email 
FROM users;

This query retrieves the first_name, last_name, and email columns from the users table.

3. WHERE Clause

The WHERE clause is used to filter records based on specific conditions.

SELECT *
FROM table_name 
WHERE condition;

SELECT * 
FROM users 
WHERE age > 25;

This query retrieves all columns for users who are older than 25.

4. LIMIT Clause

The LIMIT clause is used to specify the number of records to return.

SELECT * 
FROM table_name 
LIMIT number;

SELECT * FROM users LIMIT 10;

This query retrieves the first 10 rows from the users table.

5. DISTINCT Keyword

The DISTINCT keyword is used to return only distinct (different) values.

SELECT DISTINCT column_name
FROM table_name;

SELECT DISTINCT country 
FROM users;

This query retrieves the list of unique countries from the users table stored inside the country column.

6. COUNT Function

The COUNT function in SQL is used to count the number of rows in a table that match a specified condition. Here are a few examples to illustrate how it works:

Counting All Rows in a Table -

SELECT Count(*)
FROM table_name;

SELECT Count(*)
FROM users;

This query retrieves the count of rows from the users table.

Counting Rows with a Specific Condition -

SELECT Count (*)
FROM table_name 
WHERE condition;

SELECT * 
FROM users 
WHERE age > 25;

This query retrieves the count of rows from the users table where users have an age greater than 25.

7. SUM Function

The SUM() function in SQL is used to calculate the total sum of a numeric column.

SELECT SUM(column_name)
FROM table_name
WHERE condition;

SELECT SUM (total_sales)
FROM users; 

This query returns the sum of total_sales for all the records in the users table.

8. AVG Function

The AVG() function in SQL is used to calculate the average of a numeric column.

SELECT AVG(column_name)
FROM table_name
WHERE condition;

SELECT AVG (total_sales)
FROM users; 

This query returns the average of total_sales for all the records in the users table.

9. ORDER BY

It is used to sort the result set of a query by one or more columns. Sorting can be done in ascending order (default) or descending order.

SELECT *
FROM table_name
ORDER BY columnname;

SELECT *
FROM users
ORDER BY age;

This query returns all the records in the users table sorted in ascending order by age.

10. LIKE

is used to search for a specified pattern in a column. It is often used with WHERE clause to filter data based on partial matches. The LIKE operator can be used with two wildcard characters:

• % - Represents zero or more characters.

• _ - Represents a single character.

Here are some examples to illustrate how the LIKE operator works:

Example 1: Using % Wildcard

Suppose you have a table named users and you want to find all users whose names start with the letter 'A':

SELECT *
FROM users
WHERE name LIKE 'A%';

Example 2: Using _ Wildcard

To find all users whose names have 'B' as the second character:

SELECT *
FROM users
WHERE name LIKE '_B%';

SQL LIKE is case-insensitive in some databases like MySQL, but it is case-sensitive in others like PostgreSQL. For case-insensitive searches in PostgreSQL, you can use the ILIKE operator.

In application development, "front-end" and "back-end" are essential concepts. The front end refers to the part of the website that users see and interact with, whereas the back end encompasses the underlying processes that make everything function. A seamless collaboration between the front-end and back-end is crucial for a website's operation.

What is Front-End?

The front-end is the client side of a web application, encompassing everything that users see and interact with directly in their web browsers. It is responsible for a website's visual and interactive aspects, aiming to provide an engaging and user-friendly experience.

Key Components of the Front-end

HTML (HyperText Markup Language): It's like a skeleton that defines the structure of a web page.

CSS (Cascading Style Sheets): It's like interior designing. It provides the look and feel of a web page.

Javascript: While HTML gives structure and CSS provides style, JavaScript brings web pages to life by enabling dynamic elements and interactive features like animations, pop-up alerts, interactive forms, drop-down menus, and real-time updates without reloading the page.

Frontend Frameworks and JS Libraries

Provide tools and pre-written code to simplify the development of complex user interfaces.

Front-end CSS frameworks like Bootstrap, Semantic UI, and Tailwind CSS simplify the process of designing responsive, mobile-first web pages. They have Pre-designed CSS styles and components like buttons, forms, navbars, and more.

A JS (JavaScript) library is a collection of pre-written JavaScript code that provides functionalities to simplify the development of web applications. It focuses on enhancing the behavior and interactivity of web pages.

Examples include libraries like jQuery which Simplifies DOM manipulation, event handling, and AJAX interactions. and React which is a library for building user interfaces with a component-based architecture.

What is Back-End?

The backend is the server side of a web application. It's responsible for managing the data, business logic, and server configuration. It serves as the engine behind the scenes, enabling the front end (the user interface) to function smoothly.

Key Components of the Back-end

Server-Side Programming Languages: Backend development involves writing code that runs on the server. Some popular server-side programming languages include JavaScript, Python, Ruby, PHP, Java, .Net, etc.

These languages are used to build the logic of the web application, handle requests, and manage responses.

Databases: Databases store and manage data. There are two main types of databases:

• Relational Databases (SQL): Use structured query language (SQL) for defining and manipulating data. Examples include MySQL, PostgreSQL, and Oracle.

• NoSQL Databases: Designed for specific data models and have flexible schemas. Examples include MongoDB, Cassandra, and Redis.

Server and Hosting: Backend services need to be hosted on servers. These can be:

• On-Premises Servers: Physical servers managed by an organization.

• Cloud Servers: Virtual servers provided by cloud services such as AWS, Google Cloud, and Microsoft Azure.

• Serverless Computing: A cloud-computing execution model where the cloud provider dynamically manages the allocation of machine resources.

Backend Programming Language Frameworks

A backend framework is a collection of tools and libraries that help you build the server side of a web application. Frameworks provide pre-built components and tools, so you don't have to start from scratch.

Express.js is a popular choice for JavaScript developers. Django, a high-level Python framework. Ruby on Rails is a framework written in the Ruby programming language. Laravel is a popular PHP framework.

For enterprise-level applications, Spring is a popular Java framework with features like dependency injection and MVC architecture, catering to complex and large-scale projects.

HTTP is stateless, meaning each request is independent. However, tracking user activity is sometimes necessary. For example, on an e-commerce website, we don't want items added to a shopping cart to disappear when navigating to a different page. Therefore, we need a way to maintain this type of information.

In web development, sessions, and cookies are crucial for storing and retrieving user information.

Websites use sessions and cookies to store user data across different pages. Both are crucial for tracking information provided by visitors for various purposes. The main difference is that sessions are saved on the server-side, while cookies are saved on the user's browser (client-side). Additionally, there are several other differences between them.

In this discussion, we will explore a detailed description of sessions and cookies and how they differ.

What Are Sessions?

Sessions are a way for websites to keep track of your activity and information while you navigate through different pages. When you visit a website, a session starts, and it helps the site remember who you are and what you’re doing during that visit.

Let's take an example. Suppose you log into a web application with your username (or email) and password, then submit. You're then redirected to the dashboard page, which you can access if you're logged in.

Without a session mechanism, you wouldn't be able to access the dashboard, even after logging in. This is because HTTP requests are independent of each other, so when you request the dashboard page, the server doesn't recognize you.

How Does Session Work?

1. Session Creation: When you first visit a website, the server creates a unique session ID for you. This ID is like a temporary name tag that identifies your session.

2. Session ID Storage: The session ID is usually stored in a cookie on your browser. This allows the website to recognize your session ID when you move from page to page.

3. Data Storage on the Server: All the information about your session (like login status, items in your shopping cart, or preferences) is stored on the server. The session ID links your activity to this data.

Example of a Session in Action:

1. Login: You log into a website.

2. Session ID: The server assigns a session ID and sends it to your browser.

3. Navigation: As you browse, the session ID is sent back to the server with each request, so the server knows it’s you.

4. Persistent Data: Your login status, preferences, and actions are tracked through this session ID.

Session Lifetime:

• Temporary Nature: Sessions are temporary and usually last as long as your browser is open. Once you close your browser, the session typically ends.

• Expiration: Some sessions may expire after a certain period of inactivity, requiring you to log in again.

What are Cookies?

Cookies are small pieces of data stored on your computer by your web browser when you visit a website. They help websites remember information about you and your preferences, making your browsing experience more personalized and efficient.

Cookies can be either first-party or third-party. First-party cookies are created by the website that the user is visiting, while third-party cookies are created by domains other than the website being visited. Third-party cookies are often used for advertising and tracking purposes.

How Cookies Work:

1. Creation: When you visit a website, it may send a cookie to your browser. This cookie contains information such as a unique identifier.

2. Storage: The cookie is stored on your computer in a specific folder designated by your browser.

3. Retrieval: Each time you return to the website, your browser sends the cookie back to the server. This allows the website to recognize you and recall your preferences or login status.

Types of Cookies Based on Expiry:

• Session Cookies: These are temporary cookies that are deleted when you close your browser. They are used to store information during your browsing session, such as items in a shopping cart.

• Persistent Cookies: These cookies remain on your computer even after you close your browser. They have an expiration date and are used to remember your preferences and login details for future visits.

Managing Cookies:

1. Browser Settings: Most browsers allow you to view, delete, and manage cookies through their settings. You can choose to accept or block cookies from specific sites.

2. Privacy Tools: Use privacy tools and browser extensions to control cookie usage and enhance your online privacy.

When comparing sessions and cookies from a security perspective, sessions are generally considered more secure than cookies. Here's why:

1. Server-Side Storage: Sessions store data on the server side. Only a session ID is sent to the client, reducing the risk of sensitive data being exposed or manipulated.

2. Limited Exposure: Since the actual session data is not stored on the user's device, it is less susceptible to being stolen through client-side attacks like Cross-Site Scripting (XSS).

3. Session Expiry: Sessions often have short lifetimes and can expire after a period of inactivity or when the user logs out, reducing the window of opportunity for potential attackers.