DBMS Architecture

Single Tier Architecture

In a single-tier (1-tier) system, the user interface, application logic and data storage all exist on the same machine or platform. This is simple to build but not suitable for multi-user or distributed systems that require scalability, security, or remote access.

Use cases: local tools, single-user desktop apps, quick prototypes.

Three Tier Architecture

Three-tier architecture separates concerns into distinct layers:

• Database Tier – stores raw data and provides DBMS services (queries, transactions).
• Application Tier – business logic and processing that communicates with the DB tier.
• Presentation (Client) Tier – UI layer that renders data for end users (web pages, mobile apps).

This separation improves maintainability, security and scalability and is the most common pattern for web applications.

The two-tier architecture follows the client-server model: a client (presentation) communicates directly with a server that hosts the database and handles queries/transactions.

Components:

• Client-side application — UI and local app logic (PC, mobile, tablet).
• Server-side — handles query processing, transaction management and stores the data. Communication often happens via drivers/APIs like ODBC/JDBC.

Examples: Desktop database apps, MS Access solutions connected to a DB server.

Advantages: Simple, direct and faster communication for small deployments.

Limitations: Not ideal for large-scale web apps or many simultaneous users due to scalability and maintainability concerns.

Three-tier is the standard for scalable, secure web applications. Requests flow from client → application server → database server. The application server performs business logic and reduces direct client-database coupling.

Components

• Client (Presentation) — UI layer (browser, mobile app).
• Application Server — business logic, API endpoints, middleware.
• Database Server — persistent storage and DBMS.

Benefits

• Better security (clients do not directly access DB).
• Program-data independence and multiple views.
• Improved scalability — application servers can be scaled independently.

Demerits

More complex to implement and operate; adds network hops that can increase latency if not properly managed.