Service-Oriented vs. Client-Server Architecture: A Comparison

UPI Study › Courses › System Analysis and Design › Free lessons › Lesson 5.5 Free with a free account

Service-Oriented vs. Client-Server Architecture: A Comparison

System Analysis and Design · Chapter 5: Interface Design and Systems ArchitectureSection 5.5 · lesson 38 of 698 min · free with a free account

← What Is Systems Architecture? Key Traits and Building BlocksNext lesson: Core Concepts and Structures in Database Design →

Earn 3 college credits for System Analysis and DesignRecommended for credit by NCCRS · Computer Science 390 · self-paced · one payment, lifetime access
Enroll in System Analysis and Design · $250 →Download the syllabus (PDF)

In this lesson

Tiers, services, the enterprise service bus, and microservices.

  • Describe client-server architecture, and 2-tier, 3-tier, and n-tier designs
  • Explain services, the enterprise service bus, and loose coupling
  • Explain microservices as an evolution of SOA
  • Compare client-server and service-oriented architecture

Transcript

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

Interface Design and Systems Architecture

Service-Oriented vs. Client-Server

The last section introduced monolithic and distributed systems. This one looks at two specific ways of structuring a distributed system. Client-server architecture, with its tiers. And service-oriented architecture, with its services and its enterprise service bus. We will also meet microservices, and see why these two approaches are partners rather than rivals.

Client-Server

Requesting and Supplying Over a Network

Client-server architecture splits an application's work between two roles. A client, which requests resources or services. And a server, which supplies them over a network. The variants differ in one way. How many distinct layers, or tiers, the work is split into. That is what separates a two-tier design from a three-tier, or an n-tier, design.

Figure 5.5a

2-Tier, 3-Tier, and n-Tier

In a two-tier design, the client handles both presentation and application logic, and connects directly to a data server. A small desktop application reading and writing a local database file is a typical example. It is simple to build. But it tightly couples the client to the database. So a schema change often means updating every single client installation. A three-tier design separates presentation, application logic, and data into three independent layers. An application server sits between the client and the database. A typical web application works this way. A browser, an application server, and a database server. That isolates the database from the client entirely, and lets each tier scale, change, or be replaced on its own. An n-tier design generalizes this further. It splits the middle layer into as many tiers as the system needs, such as separate web, business logic, and integration tiers. That is common in larger enterprise systems.

Service-Oriented Architecture

Functionality as Reusable Services

Service-oriented architecture, or S O A, takes a different starting point. Instead of asking how to layer a single application, it asks how to expose an organization's functionality as independent, reusable services. Any authorized application can call those services, regardless of the language or platform that built it. Imagine a check inventory service, or a process payment service. Once published, it can be reused by a website, a mobile app, and an internal tool alike. Instead of each one reimplementing the same logic, they all call the same service.

Figure 5.5b

The Enterprise Service Bus

Most S O A implementations route that communication through an enterprise service bus, or E S B. Here, six services surround the bus. Order, inventory, payment, shipping, customer, and reporting. Each one connects only to the bus. No service connects directly to any other service. Every conversation between services passes through the bus in the middle.

Why a Bus

Routing, Transformation, and Loose Coupling

Why route everything through a bus? The E S B is middleware that handles routing, message transformation, and mediation between services. A service publishes to the bus, and consumes from it, rather than connecting directly to every service it needs. That avoids the tangled, point-to-point wiring that grows naturally as more and more systems need to integrate. This structure produces loose coupling. A service depends only on the published interface another service exposes, never on how that service is built inside. As long as the interface's contract stays the same, the team that owns a service can rewrite its internals, change its technology, or move it to new infrastructure. And none of that forces a change on the services that call it.

An Evolution of SOA

Microservices

Microservices keep S O A's core idea, independent and loosely coupled services, but push it further in three ways. Services become smaller and more narrowly scoped, usually built around a single business capability, rather than a broad enterprise function. Each service typically owns its own data store, instead of drawing on a shared enterprise database. So a change to one service's data model cannot silently break another. And communication shifts away from a centralized E S B, toward lightweight, direct protocols, such as REST over H T T P, or simple messaging. That keeps the coordinating infrastructure thin, and puts more of the responsibility in the services themselves. There is one more difference, in deployment. S O A services are often released together, on a shared schedule. Each microservice is deployed, scaled, and updated independently.

Different Questions

Client-Server vs. Service-Oriented

Now let's compare client-server and service-oriented architecture directly. In client-server, the unit of design is a tier. Presentation, logic, or data. In S O A, it is a service, a discrete, reusable business capability. Client-server usually structures one application's internal layers. S O A integrates many applications across an organization. Tiers within one application are often closely related. Services are deliberately loosely coupled, through published interfaces. Client-server scales a tier, for example by adding more application servers. S O A scales individual services, based on their own demand. And client-server tiers usually share one consistent technology stack. S O A services can use different languages or platforms, as long as the interface contract holds.

Not Competitors

They Combine in Practice

So which one should you choose? Usually, that is the wrong question. Client-server and S O A answer different questions, which is why they are not really competitors. Client-server is about how a single application's own work is layered. S O A is about how independent capabilities are exposed, and shared, across many applications. In practice, the two combine. The application logic tier of an n-tier system is very often built internally, as a set of S O A or microservice-based services.

Key Terms

The Vocabulary of This Section

Let's lock in the key terms. Client-server architecture splits work between a client that requests, and a server that supplies, over a network. Two-tier, three-tier, and n-tier designs differ in how many independent layers separate the client from the data. Service-oriented architecture exposes functionality as independent, reusable services. An enterprise service bus is middleware that routes, transforms, and mediates messages between services. Loose coupling means depending only on a published interface, never on internals. And microservices are small, independently deployed services that typically own their own data.

Key Takeaways

What to Carry Forward

To pull this together. Two-tier, three-tier, and n-tier client-server designs differ in how many independent layers separate the client from the data. S O A exposes functionality as reusable services, typically routed through an enterprise service bus. Loose coupling means a service depends only on another service's published interface. Microservices push S O A further, with smaller, independently deployed services that own their own data, and use lightweight protocols. And client-server architecture and S O A answer different questions, and commonly combine in the same system.

About System Analysis and Design at UPI Study

System Analysis and Design (Computer Science 390) is a self-paced online course of 69 video lessons in 9 chapters, from the analyst's role and requirements to UML modeling, interface and database design, testing, maintenance 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 System Analysis and Design with UPI Study

From business problem to working systemSystem Analysis and Design teaches how analysts study a business need and turn it into a system design: requirements, UML and data-flow models, interface and database design, implementation and project management. It is a core course in information systems and IT 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

System Analysis and Design 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 Service-Oriented vs. Client-Server Architecture: A Comparison

What is the difference between two-tier and three-tier client-server architecture?
In a two-tier design, the client handles both presentation and application logic and connects directly to a data server, while a three-tier design places an application server between the client and the database. Two-tier is simple but tightly couples clients to the database, so a schema change may require updating every client. Three-tier isolates the database and lets each tier scale, change, or be replaced independently.
What is an enterprise service bus in service-oriented architecture?
An enterprise service bus (ESB) is middleware that routes, transforms, and mediates messages between services in a service-oriented architecture. Each service connects only to the bus rather than directly to every other service it needs. This avoids tangled point-to-point wiring and supports loose coupling, because each service depends only on the published interfaces of others, not on how they are built inside.
How are microservices different from traditional SOA?
Microservices keep SOA's idea of independent, loosely coupled services but make them smaller, usually built around a single business capability. Each microservice typically owns its own data store instead of sharing an enterprise database, and services usually communicate through lightweight protocols such as REST over HTTP rather than a central ESB. Each microservice is also deployed, scaled, and updated independently rather than on a shared release schedule.
Is client-server architecture an alternative to service-oriented architecture?
Client-server and service-oriented architecture are not really rivals, because they answer different questions. Client-server describes how one application's work is layered into tiers such as presentation, logic, and data. SOA describes how independent, reusable capabilities are exposed and shared across many applications. In practice they combine, and the application logic tier of an n-tier system is often built as a set of SOA or microservice-based services.

About the System Analysis and Design course

How many college credits is System Analysis and Design?
System Analysis and Design (Computer Science 390) 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 System Analysis and Design cost and what is included?
$250, paid once, with lifetime access: all 69 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 System Analysis and Design take?
It is self-paced with no deadlines. The 69 lessons total about 9 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 System Analysis and Design.

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

Enroll in System Analysis and Design →Download the syllabusEvery course with PRO →
System Analysis and Design
3 credits · NCCRSEnroll →