Client-Server Networks: How They Work and When to Use Them

UPI Study › Courses › Software Engineering › Free lessons › Lesson 15.2 Free with a free account

Client-Server Networks: How They Work and When to Use Them

Software Engineering · Chapter 15: Distributed Systems, Services, and Sociotechnical TopicsSection 15.2 · lesson 96 of 1036 min · free with a free account

← Middleware: The Glue Between Software LayersNext lesson: Architecture Patterns for Building Distributed Systems →

Earn 3 college credits for Software EngineeringRecommended for credit by NCCRS · Computer Science 301 · self-paced · one payment, lifetime access
Enroll in Software Engineering · $250 →Download the syllabus (PDF)

In this lesson

How they work, how tiers split the work, and when to use them.

  • Explain how responsibility divides between client and server
  • Describe two-tier arrangements and their costs
  • Explain what a three-tier arrangement changes
  • Judge when client-server fits - and when it doesn't

Transcript

Everything said in the video, section by section (770 words). Read along, or search it.

Distributed Systems, Services, and Sociotechnical Topics

Client-Server Networks

Client-server was introduced earlier as one architectural shape among several. Here it gets a deeper treatment, as a genuine network arrangement. That means how responsibility splits across tiers, and what changes once client and server run on separate machines.

Style to Network Reality

Client-Server, Revisited

Earlier, client-server was one of several named architectural styles. A server provides services, and one or more clients request them. Revisited as a real network arrangement, the interesting question changes. How does responsibility for presentation, logic, and data actually get divided between client and server? And what does that division cost, once a real network, with real latency and real availability concerns, sits between the two?

Two-Tier

Client and Server, Directly

In a two-tier arrangement, a client connects directly to a server, often a database, with no layer in between. The client handles both presentation and business logic itself, and talks straight to the server for data. It is the simplest arrangement, but it has real costs. Business logic is duplicated across every client, so a change means updating each one. Every client needs its own direct connection, straining the server as clients grow. And clients are tightly coupled to the server's data structure, so a single schema change can break every client at once.

Three-Tier

Adding a Middle Layer

A three-tier arrangement adds a middle application tier, between a much thinner client and the data tier. Business logic moves into that middle tier, instead of being duplicated everywhere. Fixing it in one place is enough. The data tier is shielded from serving every client directly, and each tier can scale or be updated somewhat independently. This is essentially the dominant pattern behind modern web applications. A thin browser as the presentation tier, a web or application server as the logic tier, and a database as the data tier.

Figure 1

The Same Responsibilities, Split 2 Ways

Here are the same responsibilities, split two ways. In two-tier, the client holds both presentation and logic, and talks directly to the server for data. So the logic is duplicated in every client. In three-tier, the client handles only presentation. The logic lives in its own middle tier, which in turn talks to the data tier. Three-tier pulls the logic out of the client, and centralizes it in one place.

Worth Noticing

Cohesion and Coupling Again

Here is something worth noticing. Moving logic out of the client and into its own tier, is a direct application of cohesion and coupling. It separates what a user sees from what the system decides. Instead of tangling both together in the same place, each becomes a distinct, focused layer.

Strengths and Limits

What Client-Server Trades

Client-server has clear strengths. It centralizes shared data and logic, supporting consistency across many users. And it lets clients stay simpler, by leaning on the server's greater resources. The trade-off is real too. The server is a central point that every client depends on. And the network between client and server now affects responsiveness, in a way a single machine never has to account for. So a client-server system's overall availability is bounded by its server tier. If the server is down, every client is affected.

Table 1

When Client-Server Fits

Here are the two tier models side by side. In two-tier, logic lives in the client, duplicated across clients. It fits simple internal tools, and early client-server systems. In three-tier, logic lives in a middle application tier. That is the pattern behind most modern web applications. Client-server fits well when many clients need to share consistent, centrally managed data and logic. It fits less well where extreme resilience is required, or where participants need to talk to each other directly, as equals.

Apply It

A Database Schema Change

Let's apply that. The database schema needs to change. In a two-tier system, every client is tightly coupled to that data structure. So every client can break, and each one has to be updated. In a three-tier system, the middle tier can absorb the change. The clients are shielded from it entirely.

Key Terms

The Vocabulary of This Section

Let's lock in the key terms. A two-tier architecture is a client-server arrangement where the client handles presentation and logic, connecting directly to a server for data. A three-tier architecture adds a middle application tier to handle logic, separating a thin client from the data tier. And a single point of dependency is a shared component, such as a server, whose unavailability affects everything that depends on it.

Key Takeaways

What to Carry Forward

To pull this together. The key question in client-server is how presentation, logic, and data are divided. Two-tier duplicates logic across clients, and couples them tightly to the data. Three-tier centralizes logic in a middle tier, which is the pattern behind most modern web applications. The server tier bounds the availability of every client that depends on it. And client-server fits shared, centrally managed data, not participants that need to talk directly as equals.

About Software Engineering at UPI Study

Software Engineering (Computer Science 301) is a self-paced online course of 103 video lessons in 15 chapters, from process models and agile to requirements, design, user interfaces, reliability, security and project management. It carries a NCCRS credit recommendation for 3 semester credits.

Every lesson transcript is free on pages like this one, and the videos are free with a free UPI Study account. Enrolling adds a practice quiz after each lesson, the graded work and final exam that earn the credit, lifetime access, and an official transcript on completion. UPI Study has helped over 130,000 students with college credits. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Enroll now → Course details Download the syllabus All Computer Science courses Every course with PRO →

Compare: Software Engineering vs Systems Analysis

Why take it here

Why students take Software Engineering with UPI Study

How professional software gets builtSoftware Engineering covers how teams turn requirements into working, maintainable software: process models, agile, requirements, design, testing, reliability and project management. It is a core course in computer science and software degrees.
Credit at a fraction of the priceThe same 3 credits can cost $750 or more at a US college. Here it is one payment, self-paced, with lifetime access.
Finish your degree soonerTransfer credits reduce the courses you still owe, so you can graduate earlier or lighten a heavy semester.
Strengthen an applicationA completed college-level course on an official transcript shows admissions and scholarship committees you can do the work.
Study on your own scheduleNo start dates, no deadlines. Watch the lessons, practice, and take the final when you are ready.
130,000+students helped with college creditsACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Where the credit goes

Universities that work with NCCRS

Software Engineering carries a NCCRS credit recommendation. These universities work with NCCRS; some are UPI Study's signed partners. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Thomas Edison State UniversityThomas Edison State UniversitySigned partnerUniversity of the PeopleUniversity of the PeopleSigned partnerCharter Oak State CollegeCharter Oak State CollegeSigned partnerStrayer UniversityStrayer UniversitySigned partnerColumbia Southern UniversityColumbia Southern UniversitySigned partnerIndiana TechIndiana TechSigned partnerPenn StatePenn StateWorks with NCCRSSouthern New Hampshire UniversitySouthern New Hampshire UniversityWorks with NCCRSSUNYSUNYWorks with NCCRS +many more cooperating universitiesFind my college →

Find my college → Not listed? Ask Athena in the corner of this page, or book a 15-minute call.

FAQ

Questions students ask us

About Client-Server Networks: How They Work and When to Use Them

What is the difference between two-tier and three-tier architecture?
In a two-tier architecture, the client handles both presentation and business logic and connects directly to a server, often a database, for data. A three-tier architecture adds a middle application tier that holds the business logic, leaving a thin client for presentation and a separate data tier. Three-tier centralizes logic in one place instead of duplicating it across every client.
What are the disadvantages of a two-tier client-server architecture?
Two-tier duplicates business logic across every client, so one change means updating each client. Every client also needs its own direct connection, straining the server as clients grow. Clients are tightly coupled to the server's data structure, so a single database schema change can break all of them at once, whereas a three-tier middle layer could absorb it.
How does a typical web application use three-tier architecture?
A typical web application is essentially three-tier: a thin browser serves as the presentation tier, a web or application server holds the business logic, and a database forms the data tier. Separating these layers means logic is fixed in one place, the database is shielded from serving every client directly, and each tier can be scaled or updated somewhat independently.
When is a client-server architecture a poor fit?
Client-server fits less well where extreme resilience is required or where participants need to talk directly as equals. Every client depends on the server tier, so its availability bounds the whole system; if the server is down, every client is affected. The network between them also affects responsiveness. It fits best when many clients share consistent, centrally managed data and logic.

About the Software Engineering course

How many college credits is Software Engineering?
Software Engineering (Computer Science 301) carries a NCCRS credit recommendation for 3 semester credits. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.
How much does Software Engineering cost and what is included?
$250, paid once, with lifetime access: all 103 video lessons, a practice quiz after each, the graded work and final exam, and an official transcript when you finish. Students who want several courses choose UPI Study PRO instead.
Which universities accept UPI Study credits?
UPI Study has signed partner agreements with universities such as Thomas Edison State University, University of the People and Charter Oak State College, and works with universities such as Penn State, SNHU and SUNY. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities. Use "Find my college" on this page to check yours.
How long does Software Engineering take?
It is self-paced with no deadlines. The 103 lessons total about 11 hours of video; most students add reading and practice time and finish in a few weeks to a few months, on their own schedule.
How are the exams done?
Quizzes and assignments are online in the course. The final exam is taken online with proctoring; a person on the UPI Study team checks assignments, usually within two days.
How do my credits reach my college?
When the course shows 100% complete, request the official transcript from your dashboard. It is sent to the college you name, and you can send it to more than one. Check your college first with "Find my college" on this page, or ask Athena.

Ready for the full course? Earn 3 credits in Software Engineering.

103 video lessons, a quiz after each one, and the graded work that earns the credit. Recommended for credit by NCCRS.

Enroll in Software Engineering →Download the syllabusEvery course with PRO →
Software Engineering
3 credits · NCCRSEnroll →