Backend Fundamentals : part-1

Nishant Karekar

7 min read

·

Oct 23, 2026

--

Listen

Share

From Request to ProductionBasics which all backend developer must know.

Press enter or click to view image in full size

We’re going to start the series of fundaments of backend in that series we explore basics concept of the bakckend. each part has 2 topin but in two topic I will share you the best knowledge.

A better backend developer understand what happens underneath the framework.

The basic backend concept which recommended learning flow that you understand in better way.

01. HTTP & Networking Fundamentals
02. API Fundamentals
03. Backend Architecture
04. Databases
05. ORM Fundamentals
06. Authentication & Authorization
07. Security Fundamentals
08. Error Handling
09. Validation
10. Caching
11. Background Jobs & Queues
12. Webhooks & Event-Driven Systems
13. File Storage
14. Real-Time Communication
15. Testing
16. Logging & Observability
17. Performance
18. Scalability
19. Deployment & DevOps Basics
20. System Design

Don’t get demotivated. If you want to learn all these concepts in one short then the only way to build a project.

So let’s understand what are these concepts and why it is so much important.

1. HTTP & Networking fundamentals.

Before writing APIs, understand how computer communicates.

client vs server — client is a system that request something. Server is the system that receives the requests, proceess it and send the response.

A client initiates communication, while a server listens for requests, processes them, and returns responses.

IP address and Port. — An IP address identifies a machine on a network. A port identifies a specific application/service running on that machine.

Common ports:

HTTP  → 80
HTTPS → 443
SSH   → 22
MySQL → 3306

192.168.1.10 : 8000
       IP      Port

IP address identifies the host, while the port identifies the application or service on that host.

DNS — Domain Name System. DNS converts the domain name into an IP address.

google.com
     ↓
    DNS
     ↓
IP Address
     ↓
  Server

DNS is like the phonebook of the internet. It resolves domain names into IP addresses.

https / https — HTTP is a protocol used for communication between client and server. HTTPS = HTTP + TLS encryption.

HTTP — Data → readable over the network.

HTTPS — Data → encrypted → network → decrypted by server.

HTTPS secures HTTP communication using TLS (Transport Layer Security)encryption.

Request and Response — Every HTTP communication generally has two sides: Request & Response.

Request contains things like : methods, URL, Header, Body

Resposnse contains: Status code, headers, body.

An HTTP request contains information sent by the client, while the response contains the server’s result.

HTTP method : GET, POST, PUT, PATCH, DELETE — http method describe as an intent. what you want.

GET -- Retrive data --- GET /users
POST -- Create / send data --- POST /users
PUT -- Replace Entire resource --- PUT /users/10
PATCH -- Partially update resourse --- PATCH /users/10
DELETE -- Delete resourse --- DELETE /users/10

Common interview question — what is a difference between PUT & PATCH

Suppose: we want update the user age as 26

{
  "name": "John",
  "age": 25,
  "city": "Delhi"
}

PUT generally replaces the complete resource:

{
  "name": "John",
  "age": 26,
  "city": "Mumbai"
}

PATCH can update only what changed:

{
  "age": 26
}

HTTP Status Codes — Status codes tell the client what happened to the request.

2xx — Success:
200 OK
201 Created
204 No Content

3xx — Redirection:
301 Moved Permanently
302 Found
304 Not Modified

4xx — Client Error:
400 Bad Request
401 Unauthorized
403 Forbidden
404 Not Found
409 Conflict
429 Too Many Requests

4xx — Server Error: 
500 Internal Server Error
502 Bad Gateway
503 Service Unavailable
504 Gateway Timeout

Important interview distinction:

403 → You are authenticated but don't have permission
401 → Authentication problem

Headers — Headers contain metadata about the request or response.

Content-Type: application/json 
Authorization: Bearer <token> 
Accept: application/json 
User-Agent: Chrome

Common headers:

Content-Type
Authorization
Cookie
Set-Cookie
Accept
Cache-Control
Origin

Example:

POST /login
Content-Type: application/json

The server now knows that the request body contains JSON.

Headers carry metadata and control information about an HTTP request or response.

Cookies — cookies are small pieces of data stored by the browser and sent with request to the same applicable domain.

sessions. — A session keeps track of a user’s state across multiple requests. commonly used for authentication and maintaining user state.

Login → Server creates session → Browser gets session ID
→ User makes more requests → Server identifies the user

TCP/IP. — TCP/IP is the fundamental set of protocols used for communication over the internet. IP → identifies and routes data to correct machine. TCP → ensure data is delivered relibly and in the correct order.

THink: 

IP  = Where should the data go?
TCP = How do we deliver it reliably?

TCP 3-way handshaking.

Before TCP communcation begins, the clientand server establish a connection using three steps:

Client → SYN → Server
Client ← SYN-ACK ← Server
Client → ACK → Server

After this, the TCP connection is established and data can be exchanged.

TLS/SSL.

TLS (transport layer security) encrypts communication between the client and server.

CORS.

CORS (Cross-Origin Resource Sharing) is a brwoser security mechanism that controls whether one origin make request to another origin.

Frontend:
http://localhost:3000

Backend:
http://localhost:8000

Different ports = different origins.

The backend can explicitly allow the frontend:

Access-Control-Allow-Origin: http://localhost:3000

Proxy.

A proxy is a server that sits between a client and another server.

Client
   ↓
Proxy
   ↓
Server

The client communication with the proxy, and the proxy forwards the request.

Common uses: Security, privacy, caching, Filtering, Network control.

Reverse proxy

A reverse proxy sits in front of your backend servers.

Client
   ↓
Reverse Proxy
   ↓
Backend Server

Example of sotware commony used as reverse proxies include Nginx and HAProxy.

it can handle: routing, SSL/TLS termination, Caching, Security, Load balancing.

Simple difference:

Proxy:
Client → Proxy → Internet/Server

Reverse Proxy:
Client → Reverse Proxy → Your Backend Servers

Load Balancer

A load balancer distributes incoming request across multiple servers.
instead of sending every request to one server, traffic is disctributed across multiple servers.

Benefits:
1. Better performance.
2. High availibilty.
3. Scalibility.
4. Prevents one server from becoming overloaded.

🔥 How they connect together
A real — world request can look like:

Browser
   ↓
  DNS 
   ↓
Load Balancer
   ↓
Reverse Proxy
   ↓
Backend Server
   ↓
Database

And underneath the network communication:

TCP connection
      ↓
TLS encryption
      ↓
HTTP/HTTPS request
      ↓
CORS / authentication / session handling
      ↓
Backend logic

Understanding this flow will make concepts like API design, authentication, deplyment , Docker, Nginx, AWS, and system design much easier.

2. API Fundamentals

Understand how backend system expose functionality.

Learn :

Rest API.
REST (representational state transfer) is an architctural style for building APIs over HTTP.

Resource:
A resource is the thing/data your API manages.

/users
/products
/orders
/posts

A single resource can be:

/users/10

Meaning user with ID 10.

routes / endpoints:
A route/endpoint is a URL through which a client interacts with resource.

GET /users
GET /users/10
POST /users

The HTTP method + URL together define the API operation.

Request parameters:
Parameters are additinal values sent by the client with request.
common types:

path parameter:

/users/10

Query parameter:

/users?page=2&limit=10

Header:

Authorization: Bearer token

request body
Data sent from the client to the server , usually with POST, PUT or PATCH.

response body:
Data returned by the server to the client. usually accompanied by an HTTP status code such as 200, 201, 400 or 404.

JSON:
JSON (Javascritpt Object Notation) is a common format for exchanging data between client and server.
its lightweight and easy for both humans and programs to understand.

api versioning:
Versioning allows you to change an API without breaking existing clients.
for example:

/api/v1/users
/api/v2/users

If v2 changes the response structure, existing v1 clients can continue working.

pagination:
Pagination divides a large dataset into smaller pages.Useful for performance and reducing response size.

GET /users?page=2&limit=20

Meaning:
page=2 → second page
limit=20 → 20 users per page

filtering:
Filtering returns only data matching specific conditions. instead of returning every record, the API return matching records.

GET /products?category=shoes

or

GET /users?status=active

Sorting:
Sorting control the order of returned data.

GET /users?sort=name

Descending:
GET /users?sort=-createdAt

"-" commonly means descending, through the exact convention depends on the
API.

searching”
Searching finds resources based on a keyword or text.

GET /products?search=iphone

The server searches relevant fields and returns maching products.
Filtering usually means exact/structured conditions, while seaching is generally keyword/text-based.

Api documentation:
API documentation explains how developers should use your API.
It should describe: Endpoint, HTTP Method, Parameters, Request Body, Response Body, Status Codes, Authentication, Errors
Tools like Swagger/OpenAPI are commonly used for this.

Example:

POST /api/v1/users

Body:
{
  "name": "John",
  "email": "john@example.com"
}

Response: 201 Created

idempotency:
An operation is idempotent if making the same request multiple times produces the same final result.

GET → generally idempotent.
PUT → generally idempotent.
DELETE → generally idempotent.
POST → generally NOT idempotent.

Understanding backend fundamentals is about more than memorizing definitions. It’s about understanding how requests travel through a system, how data moves between components, and why we make certain architectural decisions.

Don’t try to learn everything at once. Build projects, experiment, and learn how things work under the hood.

In the next part, we’ll explore backend architecture and databases.

Follow along as we build a stronger foundation in backend development, one concept at a time.