How Modern Applications Work
Kadri, your mentor, explains why an application is a system of many components and why a tester needs to understand the architecture for integration and system testing.
What an application is made of
Hi! I’m Kadri, a QA mentor. I don’t think we’ve met yet — what’s your name?
Hi! My name is .
So, , lunch is over — time to get to work! Before we test anything, let’s look at the big picture.
A modern application isn’t a single program, it’s a whole system of many parts that constantly talk to each other.
What parts?
Take our online shop, BB Food. When a customer places an order, these all take part:
- Clients — the website in the browser and the mobile app.
- The server — receives requests and runs all the logic: calculates the total, checks discounts.
- The database — stores products, users and orders.
- External services — card payments, the delivery service, sending emails.
Wow, that’s a lot! Is it like this everywhere?
No, systems are built differently. Which components a system is made of and how they are connected is called its architecture.
There are different architectures, but the basis is almost always the same. Here are the most common:
- Client-server — one client and one server, the simplest setup.
- Monolith — the whole backend in one big application.
- Microservices — dozens or even hundreds of small services, each with its own job.
Why does a tester need to understand the architecture?
To understand what to check and how. Bugs often hide not inside one part, but where parts meet. That’s why testing is split into levels:
- Component testing (unit testing) — we check one part separately from the rest.
- Integration testing — we check how the parts talk to each other: the server saves the order to the database correctly and gets a response from the payment service.
- System testing — we check the whole system end to end, as the user sees it: from the “Place order” button to the record in the database and the email in the inbox.
So without knowing the components, I can’t tell what to check at each level?
Exactly! And one more thing: if an order didn’t appear, where do you look for the problem — in the browser, on the server, in the database or in an external service?
Someone who knows what the system is made of finds the cause faster and writes an accurate bug report, and developers fix it faster.
Got it! Where do we start?
With the basis of almost every web app — the client-server architecture. Using BB Food, we’ll see how the client, the server and the database exchange data, and what requests and response codes there are.
And at the end, we’ll look at what it looks like in big real projects. Let’s go, !
Quick reference
System components
A modern application is made of many parts: clients (a website, a mobile app), a server, a database and external services, such as a payment or delivery service.
Architecture
The architecture describes which components the system is made of and how they are connected. The most common basis is client-server; large systems split the server into microservices.
Integration testing
Checks how the components work together: the server saves data to the database correctly, gets a response from the payment service, the client shows the server’s response correctly.
System testing
Checks the whole system end to end, as the user sees it: from a button click in the browser to the record in the database and the email in the inbox.
Why a tester needs this
When you know the components, it’s clear what to check and where, and when something breaks, it’s easier to find which side the bug is on and write an accurate bug report.