Every full-stack application you build, from a simple to-do list to a sprawling social network, is built on three core pillars: the client, the server, and the database. Understanding how they work together is the first step to building professional software.

• The Client (Frontend): This is what the user sees and interacts with. It runs in their web browser. For this course, our client will be a React application. Its job is to present data and capture user input.
• The Server (Backend): This is the brain of the operation. It runs on a remote computer, not in the user's browser. We'll use Node.js and Express to build our server. It handles business logic, processes requests from the client, and talks to the database.
• The Database (Persistence): This is the application's long-term memory. It's where all the data, like user accounts, posts, and comments, is stored permanently. The server is the only part of the stack that should communicate directly with the database.

Think of it like a restaurant. The client is the menu and the dining room where you, the customer, sit. The server is the waiter who takes your order (a request), communicates it to the kitchen, and brings back your food (a response). The database is the kitchen's pantry, where all the raw ingredients are stored.

These three tiers communicate in a predictable pattern called the request-response cycle. It's a conversation that happens over the internet using a set of rules, or protocols. When you click a 'Login' button on a website, you're kicking off this cycle.

1. Request: Your browser (the client) packages up your username and password into a message. It sends this message as an HTTP request across the internet to the server's address.
2. Processing: The server receives the request. It runs its logic to check if the password is correct, often by comparing a hashed version of it against a value stored in the database.
3. Response: The server formulates a response. If the login was successful, it might send back user data and a success message. If not, it sends an error message. This response is sent back across the internet to your browser.
4. Rendering: The client receives the response. The React app then updates the user interface, either logging you in and showing your dashboard or displaying an 'Invalid password' error.

How you organize the code for these tiers defines your application's architecture. Historically, many applications were built as a monolith. In a monolithic architecture, the client-side code (like HTML templates) and the server-side code (like Node.js) are all part of the same, single codebase. They are developed, deployed, and scaled together as one unit.

This is simple to start, but it can become cumbersome as the application grows. A change to a single button on the frontend might require re-deploying the entire application.

The modern approach, and the one we'll use, is a decoupled architecture. Here, the client (React) is a completely separate project from the server (Node.js). They live in different codebases and are often deployed independently.

They communicate exclusively through an API, which acts as a formal contract. The server exposes a set of endpoints (URLs), and the client makes HTTP requests to those endpoints to get or send data. This separation allows for greater flexibility and scalability.

To build full-stack applications, you need the right tools installed on your local machine. The core of our backend is Node.js, which is a JavaScript runtime that allows us to execute JavaScript code outside of a browser. Installing Node.js also gives us npm.

npm stands for Node Package Manager. It's a command-line tool that lets us install and manage external libraries, or 'packages,' that other developers have written. These packages save us from reinventing the wheel. For example, instead of writing our own web server from scratch, we'll install and use the popular express package.

Another popular package manager is Yarn. It was developed by Facebook to address some of the performance and security shortcomings npm had in the past. While npm has since improved significantly, many developers still prefer Yarn for its speed and deterministic installs. For this course, you can use either, but we'll provide commands for npm.

With Node.js and a package manager installed, you're ready to initialize a project and start building. In the next section, we'll create our first Node.js server with Express.