Fat Client vs Fat Servers, N-tiered Software Architecture
1. Splitting an application
Every business application has three logical parts:
- Presentation logic – user interface, input and display.
- Business (application) logic – rules, calculations, workflows.
- Data logic – storage, retrieval, integrity (database).
The question is: which machine runs which part? The answer gives fat client, fat server and tiered designs.
2. Fat client (thick client)
Most processing, including business logic, runs on the client. The server mostly stores data (file server / database server).
- Examples: desktop apps with a shared DB (older Visual Basic/Delphi apps), games, MS Office.
- Pros: rich UI, works offline, server load is low, good use of PC power.
- Cons: heavy installation and updates on every client, high client hardware needs, business rules duplicated, weak security (logic and DB credentials on client), more network traffic (whole data sets move).
3. Fat server (thin client)
Most processing, including business logic, runs on the server. Client only displays results (browser, terminal).
- Examples: web apps, mainframe terminals, stored procedures in a DBMS, Chromebook/cloud apps.
- Pros: central maintenance (update once), strong security, cheap clients, consistent business rules.
- Cons: server load and cost, needs network always, scalability needs careful design, server is single point of failure.
4. Comparison
| Feature | Fat client | Fat server |
|---|---|---|
| Business logic on | Client | Server |
| Client hardware | High | Low |
| Deployment / updates | Hard, on every client | Easy, on server |
| Network traffic | High (data moves) | Low (results only) |
| Security | Weaker | Stronger |
| Offline use | Possible | Not possible |
| Scalability | Limited by DB | Better with proper design |
| Example | Desktop app + DB | Web application |
5. N-tier software architecture
An N-tier (multi-tier) architecture divides an application into separate physical/logical tiers, each with a single responsibility, communicating only with its neighbouring tier. It overcomes limits of fat client / fat server.
5.1 1-tier, 2-tier, 3-tier
| Style | Layout | Remark |
|---|---|---|
| 1-tier | UI + logic + data on one machine | Standalone desktop app |
| 2-tier | Client (UI + logic) ↔ DB server | Fat client; poor scalability |
| 3-tier | Client ↔ Application server ↔ DB server | Most common web design |
| N-tier | Extra tiers: web server, cache, API gateway, load balancer, message queue... | Enterprise systems |
5.2 The three-tier model
5.3 Role of each tier (7-mark answer, BEU 2026)
| Tier | Role | Technologies |
|---|---|---|
| Presentation (client) | Shows UI, collects input, validates basic input, sends requests, renders responses | HTML, CSS, JavaScript, React, mobile apps |
| Application / Logic (middle) | Processes requests, applies business rules, authentication, sessions, calls the database, builds responses | PHP, Java Servlets/JSP, ASP.NET, Node.js, web/app server |
| Data (database) | Stores, retrieves, secures data; handles transactions, integrity, backup | MySQL, Oracle, SQL Server, MongoDB |
Example flow – online result portal: student enters roll number in the browser → application tier checks the input and rules → queries the result table in the DB tier → formats results as HTML → browser displays.
5.4 Beyond three tiers (N-tier)
Typical extra tiers: load balancer, web server, cache (Redis), application server, message queue, API gateway, reporting/search servers, separate microservices.
5.5 Advantages of N-tier
- Separation of concerns – each tier can be changed independently.
- Scalability – scale a busy tier alone (add app servers).
- Maintainability and reusability of business logic.
- Security – database not exposed to clients; firewalls between tiers.
- Flexibility – different technologies per tier; teams work in parallel.
- Availability – replicate tiers to avoid single point of failure.
5.6 Disadvantages
More complexity and cost, extra network hops (latency), harder debugging and deployment, needs good design.
5.7 Tier vs layer
A layer is a logical division of code (presentation, business, data). A tier is a physical deployment unit (separate machine/process). One tier may hold several layers.
Frequently Asked Questions
QWhat is a fat client?
A client that performs most of the application processing, including business logic, while the server mainly stores data. Example: desktop application using a shared database.
QWhat is a fat server (thin client)?
Architecture in which the server performs most of the processing and the client only presents results, e.g. a web browser accessing a web application.
QCompare fat client and fat server.
Fat client: heavy client, hard updates, high traffic, weaker security, offline possible. Fat server: light client, central updates, low traffic, stronger security, needs a constant network. (Use the table.)
QWhat is N-tier architecture? Explain with a diagram and the role of each tier. (7 marks, BEU 2026)
Define N-tier as splitting an application into independent tiers with defined responsibilities. Draw the 3-tier SVG/flowchart: Presentation tier (browser, UI, input), Application tier (business logic, authentication, processing, DB access), Data tier (DBMS storing data). Explain a request flow with an example, mention extra tiers (cache, load balancer, queue), then list advantages (scalability, maintainability, security, flexibility) and disadvantages (complexity, latency).
QWhy is 3-tier better than 2-tier?
It removes business logic from the client and adds a middle tier that shields the database, giving better scalability, security and maintainability.
QWhat is the difference between a layer and a tier?
Layer = logical separation of code; tier = physical separation of deployment.
QWhich tier does a web browser belong to?
The presentation (client) tier.
QGive a real-world example of N-tier architecture.
E-commerce site: browser → load balancer → web server → application server (cart, payment logic) → cache → database.
QWhy is the database kept in a separate tier?
For security, independent scaling and backup, and so that several applications can share the same data safely.