Backend System Fundamentals

Backend Definition, Architecture Flow, and System Responsibilities

1. Backend System Definition

A backend system is a server environment that listens for network requests through exposed ports and processes those requests to return data or trigger actions.

The backend acts as the central processing and data management layer of an application.

A backend server typically:

listens for requests through protocols like HTTP, WebSocket, or gRPC
processes incoming data
retrieves or modifies stored data
sends responses to clients

Typical backend outputs include:

Data Type	Example
structured data	JSON responses
static resources	images, HTML files
application results	API responses

The term server comes from its role of serving resources or data to clients.

2. Backend Server Communication Model

Backend servers communicate with clients through network ports.

A port represents a communication endpoint on a server.

Common ports used by web systems:

Port	Purpose
80	HTTP traffic
443	HTTPS traffic

The backend continuously listens for requests on these ports, processes them, and returns responses.

This model forms the basis of client-server architecture.

3. Internet Request Flow to Backend Servers

When a client makes a request to a backend service, the request travels through multiple infrastructure layers before reaching the server.

High level request path:

Browser
 ↓
DNS resolution
 ↓
Internet routing
 ↓
Cloud firewall
 ↓
Server instance
 ↓
Reverse proxy
 ↓
Application server

Each layer performs a specific responsibility in routing and processing the request.

4. DNS and Domain Resolution

Users interact with servers through domain names, not IP addresses.

Example:

api.example.com

DNS (Domain Name System) translates domain names into server IP addresses.

DNS records control this mapping.

Common DNS record types:

Record Type	Purpose
A record	domain → IP address
CNAME record	domain → another domain

Example flow:

backend.example.com → 54.124.x.x

The DNS server resolves the domain and directs traffic to the appropriate machine.

5. Cloud Infrastructure and Server Instances

Backend applications are typically deployed on cloud infrastructure.

Example architecture:

Component	Purpose
cloud instance (VM)	runs application code
public IP	accessible through internet
infrastructure provider	manages physical servers

Cloud platforms allow backend systems to:

scale resources
deploy applications globally
manage network routing

Example cloud services:

AWS EC2
Google Compute Engine
Azure Virtual Machines

6. Firewall and Security Layers

Before requests reach the backend server, they pass through network firewalls.

Firewalls enforce security rules about:

which ports are accessible
which traffic is allowed
which IP addresses can connect

Example security rule:

Rule	Effect
allow port 443	enable HTTPS traffic
block other ports	prevent unauthorized access

If the required port is blocked, the request never reaches the backend server.

Firewalls act as the first security boundary of backend infrastructure.

7. Reverse Proxy Layer

A reverse proxy sits between the internet and backend application servers.

Example reverse proxy software:

Nginx
HAProxy
Apache

Purpose of reverse proxy:

Function	Explanation
request routing	forward requests to internal servers
load balancing	distribute traffic across services
SSL termination	manage HTTPS encryption
centralized configuration	manage routing rules

Example routing behavior:

incoming request
 ↓
reverse proxy
 ↓
internal server port

The reverse proxy forwards traffic to the internal application server running on localhost.

8. Application Server Layer

The application server contains the actual backend logic.

Examples:

Node.js server
Go server
Python backend
Java Spring application

These servers:

process incoming API requests
execute business logic
interact with databases
generate responses

Example internal server address:

localhost:3001

This server is typically not exposed directly to the internet.

Instead, traffic passes through the reverse proxy first.

9. Backend Data Responsibilities

The most fundamental responsibility of a backend system is data management.

Backend systems handle three major data operations:

Operation	Description
receive data	accept client input
fetch data	retrieve stored information
persist data	save data permanently

All application actions revolve around data processing.

Example user interaction flow:

User action
 ↓
client request
 ↓
backend processing
 ↓
database update
 ↓
response or notification

10. Example Data Flow: Social Media Interaction

Consider a user liking a social media post.

System flow:

User clicks like
 ↓
frontend sends request
 ↓
backend verifies user identity
 ↓
backend stores like in database
 ↓
backend identifies post owner
 ↓
notification system triggered
 ↓
post owner receives notification

The backend coordinates all system interactions and state updates.

Without the backend, distributed clients would not share a consistent application state.

11. Centralized Data Architecture

Backend systems are centralized because application data must remain consistent across users.

Centralized data storage enables:

Benefit	Explanation
data consistency	all users see the same state
security control	access rules enforced centrally
transaction management	reliable data updates
system monitoring	easier management

Without centralized servers, managing shared state across millions of users becomes extremely difficult.

12. Frontend Execution Model

Frontend applications operate differently from backend systems.

When a browser loads a website:

The browser fetches the HTML document
It downloads JavaScript, CSS, and assets
The browser executes the JavaScript locally
UI interactions are handled in the browser runtime

Frontend execution environment:

Environment	Characteristics
browser runtime	sandboxed environment
limited system access	cannot access OS resources
restricted networking	controlled by browser policies

Frontend code runs on user devices rather than centralized servers.

13. Browser Security Model

Browsers enforce strict security boundaries to protect users.

Browsers isolate applications through sandbox environments.

Sandboxing prevents web applications from accessing:

operating system files
sensitive user data
system processes

Accessible resources include:

Resource	Example
DOM	page structure
browser APIs	local storage, cookies
allowed network APIs	permitted external requests

This isolation protects users from malicious code.

14. CORS and Cross-Origin Restrictions

Browsers enforce a policy called CORS (Cross-Origin Resource Sharing).

CORS prevents JavaScript applications from calling APIs on different domains unless explicitly allowed.

Example:

frontend.example.com

Cannot call:

api.otherdomain.com

unless the server sends the correct CORS headers.

Backend servers typically manage these cross-domain policies.

15. Why Backend Logic Cannot Run in the Frontend

Executing backend logic inside browsers is not feasible due to several architectural constraints.

1. Security Restrictions

Browser sandbox environments prevent access to:

system files
environment variables
secure secrets
server resources

Backend systems require access to these resources for secure operations.

2. External API Limitations

Browsers restrict API calls through CORS policies.

Backend systems often need to communicate freely with:

external APIs
microservices
internal infrastructure

These restrictions would limit backend functionality.

3. Database Connectivity

Backend systems communicate with databases using native drivers.

Examples:

Database	Driver
PostgreSQL	pg
MongoDB	MongoDB driver

These drivers support:

socket communication
binary protocols
persistent connections

Browsers cannot support such database connections.

16. Database Connection Pooling

Backend servers maintain connection pools to databases.

A connection pool keeps multiple database connections open for reuse.

Advantages:

Benefit	Explanation
improved performance	avoid repeated connection setup
resource efficiency	reuse existing connections
scalability	handle high request volumes

Browsers cannot manage database connection pools effectively.

17. Computing Resource Control

Backend servers run on controlled infrastructure with predictable computing resources.

Server infrastructure can be scaled:

increasing CPU
increasing memory
distributing workloads

Client devices vary significantly in hardware capability.

Examples:

Device	Possible limitations
low-end smartphones	limited CPU
old computers	low memory
unstable networks	unreliable performance

Backend systems centralize heavy computation to ensure consistent application performance.

Core Architectural Principle

Backend systems exist to centralize data management, coordinate interactions between users, and provide controlled computing environments for application logic.

Without backend systems, applications would lack:

shared data consistency
centralized security control
scalable processing infrastructure
reliable communication between users.

Accessing Neural Archive...