How a PHP request starts and ends - Mechanics & Internals

Overview - How a PHP request starts and ends

What is it?

A PHP request is the process that happens when a web server runs a PHP script to respond to a user's browser. It starts when the server receives a request for a PHP page and ends when the server sends back the generated HTML or other output. During this process, PHP reads the script, executes the code, and prepares the response. This cycle happens every time someone visits a PHP page.

Why it matters

Understanding how a PHP request starts and ends helps you know what happens behind the scenes when a user visits your website. Without this knowledge, you might not realize why some code runs only once per page load or why certain data disappears after the page finishes loading. It also helps you write better, faster, and more secure PHP applications.

Where it fits

Before learning this, you should know basic PHP syntax and how web servers work. After this, you can learn about PHP sessions, request handling, and advanced topics like PHP frameworks and performance optimization.

Mental Model

Core Idea

A PHP request is like a short conversation where the server listens, thinks by running your code, and then replies before forgetting everything.

Think of it like...

Imagine ordering food at a restaurant: you tell the waiter your order (request), the kitchen prepares the meal (runs PHP code), and the waiter brings the food back to you (response). After that, the kitchen cleans up and forgets your order.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ User Browser  │──────▶│ Web Server    │──────▶│ PHP Interpreter│
└───────────────┘       └───────────────┘       └───────────────┘
        │                      │                       │
        │                      │                       │
        │                      │◀───── Executes PHP ────┤
        │                      │                       │
        │◀──────── Response ───┤                       │
        │                      │                       │
        ▼                      ▼                       ▼
   User sees page         Server sends          PHP finishes
                          generated HTML        and cleans up

Build-Up - 7 Steps

1

Foundation

What triggers a PHP request

Concept: A PHP request starts when a user asks for a PHP page through their browser.

When you type a URL like http://example.com/index.php, your browser sends a request to the web server asking for that page. The server sees the .php extension and knows it needs to run PHP code to create the page.

Result

The server prepares to run the PHP script to generate the page content.

Understanding that a PHP request begins with a user's browser asking for a PHP page helps you see the start of the whole process.

2

Foundation

How the web server handles PHP files

Concept: The web server passes the PHP file to the PHP interpreter to run the code inside.

The web server (like Apache or Nginx) does not run PHP itself. Instead, it sends the PHP file to the PHP interpreter, which reads and executes the PHP code line by line.

Result

The PHP interpreter starts running the script to create the page content.

Knowing the server and PHP interpreter work together clarifies why PHP code runs on the server, not the browser.

3

Intermediate

PHP script execution and output buffering

🤔Before reading on: do you think PHP sends output to the browser immediately or waits until the script finishes? Commit to your answer.

Concept: PHP runs the script and collects output before sending it to the browser, often using output buffering.

As PHP runs your code, it generates output like HTML. PHP can hold this output in a buffer, collecting it until the script finishes or the buffer is flushed. This lets PHP send the full page at once.

Result

The browser receives the complete page content after PHP finishes running.

Understanding output buffering explains why you sometimes see the whole page load at once, not piece by piece.

4

Intermediate

How PHP handles variables and memory per request

🤔Before reading on: do you think PHP keeps variables from one request to the next? Commit to your answer.

Concept: PHP creates variables and memory fresh for each request and clears them when done.

When PHP runs a script, it creates variables and stores data in memory. After the script finishes, PHP cleans up all variables and memory. This means each request starts with a clean slate.

Result

No data from one request automatically carries over to the next.

Knowing PHP resets memory each request helps explain why you need sessions or databases to keep data between page loads.

5

Intermediate

How PHP sends the response back to the browser

Concept: After running the script, PHP sends the generated output back through the web server to the user's browser.

Once PHP finishes running your code and has the output ready, it sends this output to the web server. The server then sends it over the internet to the browser that made the request.

Result

The user sees the web page generated by PHP in their browser.

Understanding the final step of sending the response completes the picture of the request cycle.

6

Advanced

How PHP manages request lifecycle internally

🤔Before reading on: do you think PHP keeps the same process running for all requests or starts fresh each time? Commit to your answer.

Concept: PHP uses a request lifecycle where it initializes, runs the script, and cleans up for each request, often starting fresh or using process pools.

PHP initializes environment variables, loads extensions, and prepares the runtime for each request. After running the script, it frees resources and resets state. Some setups use persistent processes (like PHP-FPM) to improve speed but still isolate requests.

Result

Each request is isolated, preventing data leaks and ensuring fresh execution.

Knowing PHP's lifecycle helps understand performance tuning and security in PHP applications.

7

Expert

Surprises in PHP request handling and cleanup

🤔Before reading on: do you think PHP always cleans up all resources perfectly after a request? Commit to your answer.

Concept: While PHP cleans up most resources, some things like persistent connections or global state in extensions can persist unexpectedly.

PHP's cleanup frees variables and memory, but extensions or persistent connections (like database pools) may keep some state. This can cause unexpected behavior if not managed carefully. Also, shutdown functions run at the end of requests for cleanup or logging.

Result

Understanding these nuances helps avoid bugs and resource leaks in complex PHP apps.

Knowing PHP's imperfect cleanup and persistent states prevents subtle bugs and improves application stability.

Under the Hood

When a PHP request starts, the web server passes the request to the PHP interpreter. PHP initializes the runtime environment, loads necessary extensions, and sets up variables like $_GET and $_POST from the request data. It then executes the script line by line, generating output. Output buffering collects this output. After execution, PHP sends the output back to the server, which forwards it to the browser. Finally, PHP runs shutdown routines and frees memory and resources, resetting the environment for the next request.

Why designed this way?

PHP was designed for simplicity and speed in web development. Running each request independently ensures security and stability by isolating requests. This stateless design fits the web's request-response model and avoids complex memory management. Persistent processes like PHP-FPM were added later to improve performance while keeping isolation. Alternatives like long-running scripts or stateful servers were avoided to keep PHP easy to use and reliable.

┌───────────────┐
│ HTTP Request  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Web Server    │
│ (Apache/Nginx)│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ PHP Interpreter│
│ Initialization│
│ Script Exec   │
│ Output Buffer │
│ Shutdown      │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ HTTP Response │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does PHP keep variables from one request to the next automatically? Commit to yes or no.

Common Belief: PHP keeps all variables and data between requests automatically.

Reality: PHP resets all variables and memory after each request; no data persists unless explicitly saved (e.g., sessions).

Why it matters: Assuming data persists can cause bugs where variables appear empty or reset unexpectedly between page loads.

Quick: Does PHP send output to the browser immediately as it runs? Commit to yes or no.

Common Belief: PHP sends output to the browser immediately as it is generated.

Reality: PHP often uses output buffering, sending the full output only after the script finishes or the buffer flushes.

Why it matters: Expecting immediate output can confuse debugging and affect how headers and redirects work.

Quick: Does PHP run the same process for all requests without restarting? Commit to yes or no.

Common Belief: PHP runs one process that handles all requests continuously without resetting.

Reality: PHP usually runs isolated environments per request, starting fresh or using process pools that reset state between requests.

Why it matters: Misunderstanding this can lead to incorrect assumptions about variable persistence and resource management.

Quick: Does PHP always clean up every resource perfectly after a request? Commit to yes or no.

Common Belief: PHP always cleans up all resources and memory perfectly after each request.

Reality: Some resources like persistent database connections or extension states may persist beyond request cleanup.

Why it matters: Ignoring this can cause memory leaks or unexpected behavior in long-running PHP setups.

Expert Zone

1

PHP's request isolation is key for security but can cause confusion when trying to share data without sessions or databases.

2

Output buffering can be controlled manually to optimize performance or fix header-related errors.

3

Persistent connections and extensions can break the stateless model, requiring careful management in production.

When NOT to use

PHP's request model is not suitable for real-time or long-lived connections like WebSockets; for those, use specialized servers or frameworks like Ratchet or ReactPHP.

Production Patterns

In production, PHP often runs with PHP-FPM or FastCGI to manage pools of worker processes for better performance. Developers use sessions, caches, and databases to maintain state across requests. Shutdown functions and error handlers ensure cleanup and logging after each request.

Connections

HTTP Request-Response Cycle

PHP request handling is a specific example of the general HTTP request-response cycle.

Understanding PHP requests deepens your grasp of how web communication works universally.

Stateless Systems in Distributed Computing

PHP's per-request reset reflects the stateless design principle in distributed systems.

Recognizing PHP's statelessness connects web development to broader system design concepts.

Restaurant Order Processing

Both involve receiving a request, processing it, delivering a result, and resetting for the next order.

This analogy helps understand the importance of isolation and cleanup in request handling.

Common Pitfalls

#1 Expecting variables to keep their values between page loads without sessions.

Wrong approach:

Correct approach:

Root cause:

Misunderstanding that PHP resets all variables after each request, so data must be stored externally to persist.

#2 Sending output before setting HTTP headers causing errors.

Wrong approach:

Correct approach:

Root cause:

Not realizing PHP buffers output and headers must be sent before any output.

#3 Assuming PHP processes all requests in one continuous process.

Wrong approach:

Correct approach:

Root cause:

Not understanding PHP's isolated request lifecycle and memory reset.

Key Takeaways

A PHP request starts when a browser asks the server for a PHP page and ends when the server sends back the generated output.

PHP runs each request independently, creating variables fresh and cleaning up after finishing to keep requests isolated and secure.

Output buffering lets PHP collect all output before sending it to the browser, which affects how and when content appears.

Persistent data between requests requires explicit storage like sessions or databases because PHP resets memory every time.

Understanding PHP's request lifecycle helps write better code, avoid common bugs, and optimize performance in real-world applications.