---
title: "Architecture before specification; client-server"
subject: "Software Engineering"
chapter: 3
key: "semester_5/software_engineering:architecture-before-specification"
source: https://www.bctengineer.com/q/semester_5/software_engineering/architecture-before-specification
site: BCT Engineering
---

# Architecture before specification; client-server

Software Engineering · Chapter 3: Architectural design

- Asked in: year not given, 4+5 marks
- Video: [SE 25: Architectural Design Model  | Complete Explanation with Examples](https://www.youtube.com/watch?v=3BaLG6KL5Ac) — CS & IT Tutorials by Vrushali 👩‍🎓
- Answer checked by Claude Sonnet 5.5 on 2026-10-14
- Page: https://www.bctengineer.com/q/semester_5/software_engineering/architecture-before-specification
- Whole chapter: https://www.bctengineer.com/md/semester_5/software_engineering/chapter-3

## Question

Why architectural design is necessary before specifications are written? Explain client server architecture with example.

## Short answer

Architectural design first structures a large system into sub-systems, so specifications can be written per sub-system, requirements allocated, and parallel development started; it also fixes interfaces and makes non-functional requirements realistic. Client-server architecture separates servers that provide services from clients that request them over a network, e.g. three-tier internet banking with browser, web server and database server.

## Answer

#### Why architectural design comes before detailed specification
In practice requirements engineering and architectural design overlap. A high-level architecture is usually proposed **before the detailed system specification is written**, for these reasons:

1. **To structure the specification** – a large system cannot be specified as one block. The architecture breaks it into sub-systems, and the detailed specification is then written sub-system by sub-system.
2. **To allocate requirements** – each requirement can be assigned to the sub-system that will satisfy it, which helps traceability and shows gaps or overlaps.
3. **Parallel work** – once sub-systems and their interfaces are known, separate teams can specify and develop them in parallel. Sub-contracts are also based on sub-systems.
4. **Non-functional requirements depend on structure** – performance, security, safety, availability and maintainability are largely decided by the architecture, so the designer must know the structure to write realistic, testable non-functional requirements.
5. **Interface definition** – interfaces between sub-systems (and with other systems) must be fixed early; they become part of the specification.
6. **Feasibility and cost** – an early architecture lets the team judge whether the requirements are achievable and estimate cost before committing to a detailed specification.
7. **Reuse decisions** – deciding early to reuse an existing architecture, product line or COTS sub-system changes what needs to be specified.

#### Client-server architecture
A **client-server architecture** is a distributed system model in which the system is organised as a set of **servers** that provide services and a set of **clients** that use those services, connected by a **network**.

Main components:
1. **Servers** – provide specific services, e.g. file server, print server, database server, web server.
2. **Clients** – request services from servers; there may be many clients running at the same time.
3. **Network** – lets clients reach servers, usually using request–reply protocols (e.g. HTTP over TCP/IP).

Clients must know the names of the servers and their services, but servers do not need to know the clients.

The application is usually divided into three logical layers: **presentation**, **application processing** and **data management**.
- **Two-tier, thin client** – the client handles only presentation; processing and data are on the server.
- **Two-tier, fat client** – the client also does application processing; the server manages data.
- **Three-tier** – presentation, processing and data run on separate machines, which scales better.

**Example: internet banking system (three-tier)**

```text
  Tier 1           Tier 2              Tier 3
  (presentation)   (processing)        (data)

+----------+
| Browser  |--+
+----------+  |   +-------------+    +------------+
+----------+  +-->| Web server  |--->| Database   |
| Browser  |----->| (login,     |    | server     |
+----------+  +-->| balance,    |<---| (accounts, |
+----------+  |   | transfers)  |    | transac.)  |
|Mobile app|--+   +-------------+    +------------+
+----------+
   requests go right, replies come back left
```

A customer logs in from a browser (tier 1). The web server (tier 2) checks the login, calculates balances and handles transfers. The database server (tier 3) stores customer and transaction data. More web servers can be added when the number of users grows.

| Advantages | Disadvantages |
|---|---|
| Data and services are distributed simply over a network | Each server is a possible single point of failure |
| Easy to add new servers or upgrade existing ones | Performance depends on the network |
| Cheap hardware can be used | Data exchange between servers may be inefficient |
| Central data management and security | Management and naming of servers needed |

## Check yourself

The answer's key points as multiple-choice questions, with the correct option and why.

1. Why is a high-level architecture proposed before the detailed specification?
   A. Specifications are not needed afterwards
   B. It breaks the system into sub-systems so the specification can be written sub-system by sub-system
   C. It replaces the need for requirements
   D. It is cheaper to skip the specification
   Answer: B. A large system cannot be specified as one block; the architecture decomposes it and allocates requirements to sub-systems. (Key point: Structuring the specification)

2. Why must the structure be known to write realistic non-functional requirements?
   A. Because they are decided mostly by the choice of font
   B. Because they are independent of structure
   C. Because only functional requirements matter
   D. Because performance, security and availability are largely decided by the architecture
   Answer: D. Non-functional properties depend largely on architecture, so testable ones need the structure first. (Key point: Non-functional requirements)

3. In client-server architecture, who needs to know whom?
   A. Clients must know the servers' names and services; servers need not know the clients
   B. Servers must know all clients
   C. Neither needs to know the other
   D. Clients and servers swap roles freely
   Answer: A. Clients request services from named servers, but servers do not need to know the clients in advance. (Key point: Client-server roles)

4. What characterises a three-tier client-server system?
   A. Presentation, application processing and data management run on separate machines
   B. The client handles only data storage
   C. There is one machine for everything
   D. Servers are also clients of the browsers
   Answer: A. Three-tier separates presentation, processing and data, which scales better than two-tier. (Key point: Three-tier)

5. Which is a disadvantage of client-server architecture?
   A. Servers can never be added
   B. Each server is a possible single point of failure and performance depends on the network
   C. No central data management is possible
   D. It needs expensive hardware only
   Answer: B. A failing server stops its service and network speed limits performance. (Key point: Disadvantage)

## Related in Software Engineering

- [Client-server versus distributed object architecture](https://www.bctengineer.com/question.md?key=semester_5%2Fsoftware_engineering%3Aclient-server-vs-distributed-object) — Software Engineering, chapter 3
- [Multiprocessor versus client-server architecture](https://www.bctengineer.com/question.md?key=semester_5%2Fsoftware_engineering%3Amultiprocessor-vs-client-server) — Software Engineering, chapter 3
- [Architectural design and multiprocessor architecture](https://www.bctengineer.com/question.md?key=semester_5%2Fsoftware_engineering%3Aarchitectural-design-multiprocessor) — Software Engineering, chapter 3

## Related in other subjects

- [Server before client; TCP reliability](https://www.bctengineer.com/question.md?key=semester_7%2Fcomputer_networks_and_security%3Atcp-server-before-client-reliability) — Computer Networks and Security, chapter 5, asked 2×
- [Client/server architecture and FTP operation](https://www.bctengineer.com/question.md?key=semester_8%2Finternet_and_intranet%3Aclient-server-ftp) — Internet and Intranet, chapter 3
- [Features of client/server architecture](https://www.bctengineer.com/question.md?key=semester_7%2Fcomputer_networks_and_security%3Aclient-server-features) — Computer Networks and Security, chapter 1
- [Short note: Client-Server and Master-Slave](https://www.bctengineer.com/question.md?key=semester_8%2Fbig_data_technologies%3Ashort-note-client-server-master-slave) — Big Data Technologies, chapter 1