Centralized Architecture
A centralized system operates through a central node. In a centralized DBMS
architecture, all database operations, user interfaces, and applications are
managed by a single central computer typically a mainframe or a powerful
server.
Users would access the mainframe through terminals connected via a network.
These terminals had minimal processing capabilities and served primarily as
input/output devices.
Working:
All user interactions in a centralized DBMS take place through the
terminals. Terminals are some basic interfaces connected to the
mainframe. These terminals do not process the data themselves. They
send the input commands to the server. The command handles the
execution. The server processes the commands and returns the results
to the terminals for display
Characteristics:
Single point of control.
Easy to manage data because it’s all in one place.
If the central server fails, the whole system goes down.
Drawbacks:
Single Point of Failure
Scalability Issues: As the number of users grows, the mainframe may
struggle to handle the increased load
Real-life Example:
University examination system (old style):
o One main computer stores all student records, marks, and reports.
o Terminals in different departments just access that data.
Consider a university that uses a centralized DBMS to manage its student database. All student-
related queries such as checking grades or registering for classes are processed on a central
mainframe.
Client server Architecture:
Clients: Machines or software applications where the users interact. These
handle user inputs and present results.
Servers: Systems that store the database and execute data processing tasks.
A client-server architecture for DBMS is one in which data is stored on a
central server, but clients connect to that server in order to access and
manipulate the data.
In this model, the database server houses the DBMS and the
actual database, handling data storage, query processing, and
transaction management.
The client, usually a front-end application, interacts with the
server, requesting data and presenting it to the end user. This
separation enhances data integrity, security, and management
efficiency, allowing for a more robust and scalable system.
This type of architecture is more complex than a centralized architecture, but it
offers several advantages over the latter.
One of the main benefits of a client-server architecture is that it is more
scalable than a centralized architecture. As the number of clients and/or
the amount of data increases, the server can be upgraded or additional servers
can be added to handle the load. This allows the system to continue functioning
smoothly even as it grows in size.
Another advantage of a client-server architecture is that it is more fault-
tolerant than a centralized architecture. If a single server goes down,
other servers can take over its responsibilities, and clients can still access
the data. This makes the system less likely to experience downtime, which is a
crucial factor in many business environments.
2-Tier Architecture (Client-Server)
Definition: The application (client) talks to the database (server).
On the client side, the user interfaces and application programs are run. The
application on the client side establishes a connection with the server side to
communicate with the DBMS.
Client Layer (Tier 1): This is the user interface that library staff or users
interact with. For example they might use a desktop application to search
for books, issue them, or check due dates.
Database Layer (Tier 2): The database server stores all the library
records such as book details, user information and transaction logs.
The client layer sends a request (like searching for a book) to the
database layer which processes it and sends back the result. This
separation allows the client to focus on the user interface, while the server
handles data storage and retrieval.
📌 Example
A bank teller’s desktop application.
o The teller uses a software (client app) installed on their computer.
o That app directly connects to the bank’s database server to fetch account details.
Advantages of 2-Tier Architecture
Easy to Access: 2-Tier Architecture makes easy access to the database, which
makes fast retrieval.
Scalable: We can scale the database easily, by adding clients or upgrading
hardware.
Drawbacks:
Scalability Limits − As more clients connect, the server may face
performance bottlenecks.
Security Issues: Clients connect directly to the database, which can
make the system more vulnerable to attacks or data leaks.
3-Tier Architecture (Client – Application Server – Database)
There is an additional application server between the client and database. The client never talks
to the DB directly.
Presentation Layer (Client) − Displays data and collects user input.
Application Layer (Middle Tier) − Processes user requests and interacts with the database.
Data Layer (Server) − Handles database storage and management.
Example in real life:
Online shopping website (Amazon, Flipkart)
o You use your phone app (client).
o The app sends request to a web/app server (middle layer).
o The server processes business logic, then queries the database, and sends results
back.
Like you order food through Swiggy app → The app (client) sends request to Swiggy server
(application) → Server contacts the restaurant’s system (database) → Food comes back to you.
An example of a DBMS that uses a client-server architecture is MySQL, an open-
source relational database management system. MySQL uses a multi-threaded
architecture, where multiple clients can connect to the server and make
requests simultaneously. The server processes these requests and returns the
results to the appropriate client.
Client-Server Architecture
General idea: Clients request, server responds.
Can be 2-tier, 3-tier, or even n-tier depending on how many layers you add.
🔹 2-Tier Client-Server
Client ↔ Database Server (direct connection).
Example:
o A desktop application directly connecting to Oracle/MySQL DB.
o MS Access front-end with SQL Server backend.
🔹 3-Tier Client-Server
Client ↔ Application Server ↔ Database Server
Middle layer = business logic / application server.
Example:
o Online banking:
Browser/mobile app (client) → Bank’s app server (business rules,
authentication) → DB server (transactions).
o E-commerce apps (Amazon, Flipkart).
