Multi-tier architecture patterns in AWS - Step-by-Step Execution

Process Flow - Multi-tier architecture patterns

User Request

↓

Presentation Tier

↓

Application Tier

↓

Data Tier

↓

Response to User

User requests go through layers: first the presentation, then application, then data, and back with a response.

Execution Sample

AWS

User -> ELB -> EC2 App Servers -> RDS Database

Shows a simple multi-tier flow: user request hits load balancer, then app servers, then database.

Process Table

Step	Component	Action	Input	Output
1	User	Sends request	User input	HTTP request to ELB
2	Elastic Load Balancer	Receives request	HTTP request	Forwards to App Server
3	App Server (EC2)	Processes request	Request data	Queries Database
4	RDS Database	Executes query	SQL query	Returns data
5	App Server (EC2)	Builds response	Database data	HTTP response
6	Elastic Load Balancer	Sends response	HTTP response	Response to User
7	User	Receives response	HTTP response	Displays content

💡 User receives response; request cycle completes.

Status Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	Final
Request	User input	At App Server	At App Server	At App Server (response)	At User (response)
Data	N/A	N/A	Database query result	Response built	Displayed content

Key Moments - 3 Insights

Why does the user request go through the load balancer before reaching the app servers?

The load balancer distributes incoming requests evenly to app servers for reliability and scalability, as shown in execution_table step 2.

What happens if the database is slow to respond?

The app server waits for the database query result before building the response, delaying steps 4 and 5 in the execution_table.

Can the user communicate directly with the database?

No, the user only interacts with the presentation tier; the database is accessed only by the application tier, as shown in steps 1 and 4.

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the app server query the database?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Check the 'Component' and 'Action' columns for database query.

According to variable_tracker, where is the request after step 4?

A At User

B At App Server

C At ELB

D At Database

💡 Hint

Look at the 'Request' row and the 'After Step 4' column.

If the load balancer is removed, what changes in the execution flow?

A User sends request directly to app servers

B Database receives requests directly

C App servers send responses to ELB

D User communicates directly with database

💡 Hint

Consider the role of ELB in step 2 of execution_table.

Concept Snapshot

Multi-tier architecture splits cloud apps into layers:
- Presentation tier handles user interface
- Application tier processes logic
- Data tier stores info
Requests flow through these tiers for scalability and security.

Full Transcript

Multi-tier architecture means splitting an application into layers: presentation, application, and data. The user sends a request that first hits the presentation tier, often a load balancer, which forwards it to application servers. These servers process the request and query the data tier, usually a database. The data is returned back through the layers to the user. This pattern helps keep the system organized, scalable, and secure by separating concerns and controlling access between layers.