The Code Writers: Frontend, Backend, and QA

If the BA, PO, and PM are the architects, then Frontend developers, Backend developers, and QA engineers are the builders, engineers, and inspectors. Each sees a completely different part of the product — and understanding those different perspectives is what makes you a great tester.

Learning Objectives

By the end of this lesson you will be able to:

• Describe what Frontend and Backend developers build and where their code lives
• Explain how these two worlds interact through APIs
• Articulate QA's unique role as the quality bridge between them

Frontend Developer — The Architect of What You See

The Frontend developer builds everything you interact with in a browser or mobile app: buttons, forms, navigation menus, animations, layout. Their code runs in your browser, not on the server.

Technologies: HTML, CSS, JavaScript, frameworks like React, Vue, or Angular.

What Frontend developers care about:

• Does it look right on all screen sizes (responsive design)?
• Does it match the designer's mockup?
• Is it fast to load?
• Do interactions feel smooth?

Where bugs hide on the Frontend:

• Layout breaks on certain browsers or screen sizes
• Form validations that don't trigger correctly
• UI states that don't update after an action (e.g., button stays active after click)
• Accessibility issues

QA angle: When you test the UI, you're testing the Frontend. A broken button layout or a form that doesn't submit is a Frontend bug. Screenshot the exact browser version and screen resolution — your Frontend colleague will thank you.

Backend Developer — The Brain Behind the Interface

The Backend developer builds the server side: the code that handles business logic, stores and retrieves data from databases, and exposes APIs that the Frontend calls.

Technologies: Java, Python, Node.js, Go, databases (PostgreSQL, MySQL), REST and GraphQL APIs.

What Backend developers care about:

• Is the data correct and consistent?
• Are API responses fast and correct?
• Is business logic applied properly (e.g., "users under 18 cannot purchase")?
• Is it secure?

Where bugs hide on the Backend:

• Incorrect data returned from an API
• Missing validation (e.g., accepts negative quantities in an order)
• Authentication/authorisation failures
• Edge cases in business rules

QA angle: Testing the Backend means testing the API directly — sending requests with tools like Postman or a REST client, checking not just the happy path but also boundary values, invalid inputs, and missing fields.

How Frontend and Backend Talk: The API Contract

The Frontend and Backend communicate through an API (Application Programming Interface). The Backend exposes endpoints; the Frontend calls them.

User fills form → Frontend sends POST /api/v1/orders → Backend validates, saves to DB → Returns order ID
                                                      ↓
Frontend displays "Order confirmed #12345"

This API contract is a rich source of bugs. The Frontend might send the wrong data type. The Backend might return an unexpected error code. Both sides might have different ideas of what "required field" means.

Your job as QA: Test the contract from both sides.

QA Engineer — The Quality Bridge

Here's the most important thing to understand about your role: you are not the last line of defence. You are a quality advocate embedded in the entire team.

A QA engineer who only clicks buttons at the end of a sprint is using 10% of their value. A QA engineer who:

• Reviews requirements during analysis (and finds ambiguities before they become bugs)
• Pairs with developers during coding (to clarify expected behaviour early)
• Tests both the UI and the API
• Documents defects clearly enough that the right person fixes them in one round

...is using 100% of their value.

QA bridges Frontend and Backend because:

• A bug might be caused by the Frontend sending bad data, or by the Backend mishandling good data — and only QA tests the full flow
• Requirements are written for features, not layers — the QA test case is the only place where both layers are verified together

Career insight: The distinction between "I found a Frontend bug" and "I found a Backend bug" matters for assignment. Learn to make that call confidently. It saves everyone time.

Summary

Next up: the three roles that make sure your tested code actually reaches users in one piece.