← Back to all projects

LEARN PHP DEEP DIVE

Learn PHP: From Web Scripts to Modern Backend

Goal: Deeply understand the PHP language, from its foundational request-response model to its modern, robust ecosystem. Learn its strengths, how it differs from other languages, and how it operates “behind the scenes” with web servers.

Why Learn PHP?

PHP was built for the web, and this focus is its greatest strength. Its design philosophy is pragmatic, prioritizing getting things done quickly and efficiently in a web context. While other languages have had web frameworks bolted on, PHP was designed from the ground up to handle HTTP requests, forms, and databases.

Learning PHP teaches you the core of server-side web development in its most direct form. You will gain a deep appreciation for the stateless, “share-nothing” architecture that makes PHP applications easy to deploy, scale, and reason about.

After completing these projects, you will:

  • Understand the complete PHP request lifecycle, from web server to browser.
  • Write secure, modern, object-oriented PHP.
  • Master database interaction with PDO and prevent SQL injection.
  • Use Composer to manage dependencies and build with a modern toolchain.
  • Build applications using a major framework like Laravel, understanding the MVC pattern it provides.
  • Know how PHP works with Nginx/Apache via PHP-FPM, and understand the role of OPcache.

Core Concept Analysis

The PHP Request-Response Lifecycle (Its Superpower)

PHP’s “share-nothing” architecture is its defining characteristic. Unlike long-running Node.js or Java servers, a PHP process is typically born, lives for a few milliseconds to handle a single request, and then dies.

┌──────────────────────────────────────────────────┐
│                  USER'S BROWSER                  │
│  (Requests http://example.com/index.php?id=123)  │
└──────────────────────────────────────────────────┘
                 │
                 ▼ HTTP Request (GET /index.php?id=123)
┌──────────────────────────────────────────────────┐
│              WEB SERVER (Nginx/Apache)           │
│ (Sees .php file, forwards request to PHP-FPM)    │
└──────────────────────────────────────────────────┘
                 │
                 ▼ FastCGI Protocol
┌──────────────────────────────────────────────────┐
│           PHP-FPM (Process Manager)              │
│  (Grabs an idle PHP worker process from a pool)  │
└──────────────────────────────────────────────────┘
                 │
                 ▼
┌──────────────────────────────────────────────────────────────────────────┐
│                        ONE PHP PROCESS (Execution)                       │
│                                                                          │
│  1. Starts up. Initializes everything.                                   │
│  2. Populates Superglobals:
│     - $_GET['id'] = "123"
│     - $_SERVER['REQUEST_URI'] = "/index.php?id=123"
│     - ...and $_POST, $_COOKIE, etc.                                      │
│  3. Zend Engine parses your script into Opcodes (and caches them).       │
│  4. Executes your script (connects to DB, gets data).                    │
│  5. `echo "<h1>Hello</h1>"` sends HTML back to PHP-FPM.                  │
│                                                                          │
└──────────────────────────────────────────────────────────────────────────┘
                 │
                 ▼ Script finishes. All memory is wiped. The process is clean.
┌──────────────────────────────────────────────────┐
│           PHP-FPM (Process Manager)              │
│ (Returns the worker process to the idle pool)    │
└──────────────────────────────────────────────────┘
                 │
                 ▼ HTTP Response (HTML content)
┌──────────────────────────────────────────────────┐
│              WEB SERVER (Nginx/Apache)           │
│   (Sends the generated HTML back to the user)    │
└──────────────────────────────────────────────────┘
                 │
                 ▼
┌──────────────────────────────────────────────────┐
│                  USER'S BROWSER                  │
│          (Renders the "<h1>Hello</h1>")          │
└──────────────────────────────────────────────────┘

Key Concepts Explained

1. Superglobals: The World Outside

PHP provides a set of predefined variables that contain all the information about the incoming request. They are the entry point for all external data.

  • $_GET: An associative array of variables passed in the URL query string.
  • $_POST: An associative array of variables passed in the body of a POST request (from a form).
  • $_FILES: Information about uploaded files.
  • $_SESSION: Data that persists across multiple requests for the same user.
  • $_COOKIE: Data from HTTP cookies.
  • $_SERVER: Information about the server environment and request headers.

2. The Zend Engine, Opcodes, and OPcache

  • Zend Engine: The open-source interpreter at the heart of PHP. It’s a virtual machine that executes PHP code.
  • Parsing: When a PHP script is run, the Zend Engine first parses it into an abstract syntax tree (AST).
  • Compilation to Opcodes: The AST is then compiled into opcodes, which are low-level, machine-like instructions for the Zend Engine (e.g., ADD, FETCH_CONST, ECHO).
  • OPcache: Executing the parser and compiler on every request is slow. OPcache is a built-in extension that stores these pre-compiled opcodes in shared memory. When the same script is requested again, PHP can skip the parsing/compilation steps and jump straight to execution, making it dramatically faster.

3. PHP-FPM (FastCGI Process Manager)

This is the standard way to run PHP in production.

  • Instead of the web server having a PHP module built-in, it communicates with a separate PHP-FPM service.
  • PHP-FPM maintains a pool of worker processes.
  • When a request comes in, the web server (Nginx) passes it to PHP-FPM, which finds a free worker, gives it the script to run, and returns the output. This is more efficient and scalable than creating a new process for every single request.

4. Composer and PSR-4 Autoloading

The foundation of modern PHP.

  • Composer: A dependency manager for PHP. You declare the libraries you need in a composer.json file, and Composer downloads them and manages their versions.
  • Autoloading: In the “old days,” you would use require_once 'MyClass.php'; at the top of every file. Modern PHP uses an autoloader. When you try to use a class that hasn’t been defined yet (e.g., new App\Controllers\HomeController();), the autoloader intercepts the error, figures out the file path from the namespace (App\Controllers\HomeController -> src/Controllers/HomeController.php), and includes it automatically. This is defined by the PSR-4 standard and set up for you by Composer.

Project List

These projects will take you on a journey from simple “raw” PHP scripts to building structured, modern applications with a full-stack framework.

Project 1: A “Contact Us” Form

  • File: LEARN_PHP_DEEP_DIVE.md
  • Main Programming Language: PHP
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 1: Pure Corporate Snoozefest
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 1: Beginner
  • Knowledge Area: Web Forms / Server-Side Scripting
  • Software or Tool: A local PHP development server
  • Main Book: PHP Manual (online)

What you’ll build: A simple HTML form that takes a user’s name, email, and message. When submitted, a PHP script will validate the input and use the mail() function to send you an email.

Why it teaches PHP: This is the most fundamental PHP task. It teaches you how to get data from a browser ($_POST), how to process it on the server, and how to perform an action. It’s the “Hello, World!” of backend programming.

Core challenges you’ll face:

  • Getting POST data → maps to understanding the $_POST superglobal
  • Validating input → maps to basic security checks (is the email valid? is the message empty?)
  • Preventing Cross-Site Scripting (XSS) → maps to using htmlspecialchars() to safely display user input
  • Handling form state → maps to showing success/error messages and repopulating the form after submission

Key Concepts:

  • $_POST superglobal: PHP Manual - $_POST
  • Form Validation: PHP The Right Way - “Forms”
  • htmlspecialchars(): PHP Manual - htmlspecialchars

Difficulty: Beginner Time estimate: A few hours Prerequisites: Basic HTML.

Real world outcome: A working contact form on a web page. You submit the form, and an email with the form’s contents appears in your inbox.

Implementation Hints:

  • Create an index.php file.
  • At the top, use if ($_SERVER["REQUEST_METHOD"] == "POST") { ... } to check if the form has been submitted.
  • Inside the if block, access the data: $name = $_POST['name'];.
  • Always validate and sanitize user input. Never trust it.
  • Use filter_var($email, FILTER_VALIDATE_EMAIL) to check for a valid email format.
  • To display user-submitted data back on the page (e.g., in an error message), wrap it in htmlspecialchars() to prevent a malicious user from injecting <script> tags.

Learning milestones:

  1. You can receive and var_dump() the $_POST data → You understand how data travels from browser to server.
  2. You can send an email with the form data → You’ve performed a server-side action.
  3. Your form displays helpful error messages → You are handling user input gracefully.
  4. You use htmlspecialchars() on all user-provided output → You have learned the most basic rule of web security.

Project 2: Simple Blog with a Database

  • File: LEARN_PHP_DEEP_DIVE.md
  • Main Programming Language: PHP
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 2: Practical but Forgettable
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Database Interaction / Dynamic Content
  • Software or Tool: MySQL/MariaDB, PDO
  • Main Book: “PHP and MySQL: The Missing Manual” by Brett McLaughlin

What you’ll build: A simple blog where you can create, read, update, and delete posts (CRUD). Posts will be stored in a MySQL database.

Why it teaches PHP: This is the next logical step: dynamic content from a database. You will learn the modern, secure way to talk to a database using PDO (PHP Data Objects) and prepared statements, which is the single most important skill for preventing SQL injection attacks.

Core challenges you’ll face:

  • Connecting to a database → maps to using the PDO extension
  • Preventing SQL Injection → maps to learning and using prepared statements
  • Structuring your application → maps to the “Front Controller” pattern, where all requests go to index.php which then includes other files
  • Creating a simple routing system → maps to using a $_GET parameter like ?action=show&id=5 to decide what to do

Key Concepts:

  • PDO: PHP The Right Way - “Databases”
  • Prepared Statements: PDO Manual - PDO::prepare
  • SQL Injection: OWASP - “SQL Injection”

Difficulty: Intermediate Time estimate: 1-2 weeks Prerequisites: Project 1, basic SQL knowledge.

Real world outcome: A website with a homepage listing all blog posts, a page to view a single post, and a simple admin area to add/edit posts.

Implementation Hints:

  • Use PDO, not the old mysql_* functions (they are deprecated and insecure).
  • A typical PDO connection: $pdo = new PDO('mysql:host=localhost;dbname=blog', 'user', 'pass');
  • Always use prepared statements for queries involving user input: 
    // GOOD: Uses a placeholder
$stmt = $pdo->prepare('SELECT * FROM posts WHERE id = ?');
$stmt->execute([$postId]);
$post = $stmt->fetch();

// BAD: Concatenates user input directly into the query
// $pdo->query("SELECT * FROM posts WHERE id = " . $postId); // VULNERABLE!
  • Create a simple router in index.php: 
    $action = $_GET['action'] ?? 'home'; // Default to 'home'
if ($action === 'home') {
    // Logic for homepage
} elseif ($action === 'show') {
    // Logic for showing a single post
}

Learning milestones:

  1. You can connect to a database and fetch all posts for the homepage → You’ve mastered basic PDO queries.
  2. You can view a single post based on an ID from the URL → You are using prepared statements to safely handle user input.
  3. You can create a form that inserts a new post into the database → You’ve implemented the “Create” part of CRUD.
  4. You can explain exactly what an SQL injection attack is and how your code prevents it → You’ve learned a critical security concept.

Project 3: User Authentication System from Scratch

  • File: LEARN_PHP_DEEP_DIVE.md
  • Main Programming Language: PHP
  • Coolness Level: Level 2: Practical but Forgettable
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Security / Session Management
  • Software or Tool: PHP Sessions, Password Hashing API
  • Main Book: N/A, use PHP Manual and security blogs.

What you’ll build: A system for users to register for an account, log in, and log out. You will protect certain pages so they are only visible to logged-in users.

Why it teaches PHP: This project dives into two critical, security-sensitive areas: password storage and session management. You will learn the modern, correct way to handle passwords (password_hash) and how to maintain user state across multiple requests using PHP sessions.

Core challenges you’ll face:

  • Storing passwords securely → maps to using password_hash() and password_verify(), never storing plain text passwords
  • Managing user sessions → maps to session_start(), $_SESSION, and session_destroy()
  • Protecting routes → maps to checking isset($_SESSION['user_id']) at the top of a page and redirecting if not set
  • Preventing session fixation/hijacking → maps to using session_regenerate_id() after a successful login

Key Concepts:

  • Password Hashing: PHP Manual - password_hash
  • PHP Sessions: PHP The Right Way - “Sessions”
  • session_regenerate_id(): PHP Manual - session_regenerate_id

Difficulty: Intermediate Time estimate: 1-2 weeks Prerequisites: Project 2.

Real world outcome: A website with a login page. After logging in, you see a “Welcome, [Username]!” message and a “Logout” link. If you try to access a protected “dashboard” page without being logged in, you are redirected to the login page.

Implementation Hints:

  • When a user registers, store their username and the result of password_hash($plainTextPassword, PASSWORD_DEFAULT) in the database.
  • When a user tries to log in, fetch the user record from the database by their username. Then, check if the submitted password is correct using if (password_verify($submittedPassword, $user['password_hash'])) { ... }.
  • If the password is correct:
    1. Call session_regenerate_id(true); to prevent session fixation.
    2. Set session variables: $_SESSION['user_id'] = $user['id']; and $_SESSION['username'] = $user['username'];.
    3. Redirect them to the dashboard.
  • On protected pages, put this at the very top: 
    session_start();
if (!isset($_SESSION['user_id'])) {
    header('Location: /login.php');
    exit();
}
  • The logout script should call session_destroy() and redirect to the homepage.

Learning milestones:

  1. A user can register and their password hash is stored in the DB → You understand secure password storage.
  2. A user can log in with the correct password but not the wrong one → You understand password_verify.
  3. A logged-in user can access a protected page, but a logged-out user cannot → You’ve mastered session-based access control.
  4. You can explain why you should never, ever store passwords in plain text or with simple MD5/SHA1 hashing → You’ve internalized a core security principle.

Project 4: An Introduction to Modern PHP with Composer

  • File: LEARN_PHP_DEEP_DIVE.md
  • Main Programming Language: PHP
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 2. The “Micro-SaaS / Pro Tool”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Tooling / Dependency Management / Project Structure
  • Software or Tool: Composer, Packagist
  • Main Book: “PHP The Right Way” (online resource)

What you’ll build: Refactor your blog (Project 2/3) into a modern structure. You will introduce Composer to manage dependencies and autoload your classes using the PSR-4 standard. You’ll add an external library, like a logging library (Monolog), to see it in action.

Why it teaches PHP: This is the bridge from “PHP as a collection of scripts” to “PHP as a modern, structured application.” Understanding Composer and autoloading is not optional for any serious PHP development today. It unlocks the entire open-source ecosystem.

Core challenges you’ll face:

  • Setting up Composer → maps to creating your first composer.json file
  • Understanding autoloading → maps to moving from require_once to namespaces and PSR-4
  • Using a third-party package → maps to finding a package on Packagist and using it in your code
  • Organizing code into classes → maps to refactoring your procedural code into logical classes (e.g., PostController, PostModel)

Key Concepts:

  • Composer: GetComposer.org official documentation
  • PSR-4 Autoloader: PHP-FIG - PSR-4
  • Namespaces: PHP Manual - “Namespaces”
  • Packagist: The main Composer repository.

Difficulty: Intermediate Time estimate: Weekend Prerequisites: Project 3, basic understanding of Object-Oriented Programming (OOP).

Real world outcome: Your blog project now has a vendor directory, a composer.json file, and your code is organized into classes with namespaces. You no longer have any require or include statements for your own classes.

// composer.json
{
    "name": "your-name/blog",
    "description": "A simple blog.",
    "require": {
        "monolog/monolog": "^2.0"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

And your code now looks like this:

// index.php
require_once __DIR__ . '/vendor/autoload.php';

use App\Controllers\PostController;

$controller = new PostController();
$controller->show();

// src/Controllers/PostController.php
namespace App\Controllers;

use Monolog\Logger;
use Monolog\Handler\StreamHandler;

class PostController {
    public function show() {
        $log = new Logger('name');
        $log->pushHandler(new StreamHandler('app.log', Logger::WARNING));
        $log->warning('Showing a post!');
        // ...
    }
}

Learning milestones:

  1. You initialize a project with composer init → You’ve started a modern PHP project.
  2. You add a library like Monolog with composer require → You understand dependency management.
  3. You successfully autoload one of your own classes using a namespace → You’ve grasped PSR-4 and can eliminate require_once.
  4. You can’t imagine starting a new PHP project without Composer → You are now a modern PHP developer.

Project 5: Building a Simple MVC Framework from Scratch

  • File: LEARN_PHP_DEEP_DIVE.md
  • Main Programming Language: PHP
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Software Architecture / MVC Pattern
  • Software or Tool: Your own framework
  • Main Book: “PHP Objects, Patterns, and Practice” by Matt Zandstra

What you’ll build: Your own bare-bones Model-View-Controller (MVC) framework. It will have a Router that maps URLs to Controller actions, Controllers to handle logic, and Views to render HTML.

Why it teaches PHP: This project demystifies the “magic” behind frameworks like Laravel and Symfony. By building the core components yourself, you’ll gain a deep and lasting understanding of the MVC pattern and why it’s used for building large, maintainable web applications.

Core challenges you’ll face:

  • Building a Router → maps to parsing the REQUEST_URI and matching it against a list of predefined routes to find the right controller
  • Creating Controller/Action logic → maps to instantiating the correct controller class and calling the correct method based on the route
  • Separating logic from presentation → maps to having controllers prepare data and pass it to simple “View” scripts that contain mostly HTML
  • Implementing a base Model → maps to creating a reusable class for database interactions

Key Concepts:

  • MVC Pattern: A deep dive into the Model-View-Controller architecture.
  • Routing: The process of mapping a URL to code.
  • Dependency Injection: A simple implementation where you pass dependencies (like a database connection) into your controllers.

Difficulty: Advanced Time estimate: 2-3 weeks Prerequisites: Project 4. Solid OOP knowledge.

Real world outcome: A simple but well-structured application. A URL like /posts/5 will be transparently routed to the show method on your PostController, which will fetch post #5 from a PostModel and render it using a post_show.php view file. The internal structure will mirror a professional framework.

Implementation Hints:

  1. Router:
    • All requests go to index.php.
    • Parse $_SERVER['REQUEST_URI'].
    • Have a simple array of routes: ['GET /posts/{id}' => [PostController::class, 'show']].
    • Write a regex to match the URI against your routes and extract parameters like {id}.
  2. Controller:
    • The router will instantiate the controller (e.g., new PostController()) and call the method (e.g., $controller->show($id)).
  3. View:
    • Your controller method should not echo HTML.
    • Instead, it should call a view() function, passing the name of the view file and the data.
    • The view() function will extract() the data into local variables and then require the PHP view file, which can now use those variables.

Learning milestones:

  1. Your router can dispatch / to a HomeController → You have a working front controller and router.
  2. Your router can handle variable routes like /posts/123 and pass 123 to the controller → You’ve implemented parameter extraction.
  3. Your controller fetches data and passes it to a View file for rendering → You have successfully separated logic from presentation.
  4. You look at Laravel or Symfony and say, “I see what’s going on here” → The project has fulfilled its purpose.

Project 6: Building a Real Application with Laravel

  • File: LEARN_PHP_DEEP_DIVE.md
  • Main Programming Language: PHP
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 4. The “Open Core” Infrastructure
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Full-Stack Frameworks / RAD
  • Software or Tool: Laravel, Eloquent ORM, Blade Templating
  • Main Book: Laravel Documentation (“The documentation is the book”)

What you’ll build: Rebuild your blog application (or a new, more complex idea like a simple e-commerce site) using Laravel.

Why it teaches PHP: This project teaches you how to be a productive, professional PHP developer. After building a framework from scratch, you will now appreciate the power and elegance a mature framework provides. You’ll learn about Object-Relational Mapping (ORM), powerful templating engines, database migrations, and the command-line tools that make development a joy.

Core challenges you’ll face:

  • Thinking in “The Laravel Way” → maps to learning the conventions and lifecycle of the framework
  • Using an ORM (Eloquent) → maps to interacting with your database using objects (Post::find(1)) instead of writing SQL
  • Using a Templating Engine (Blade) → maps to writing clean views with layouts, includes, and loops (@foreach)
  • Database Migrations → maps to version-controlling your database schema in PHP files
  • The Service Container → maps to understanding dependency injection and how Laravel manages its components

Key Concepts:

  • Eloquent ORM: Laravel Docs - “Eloquent ORM”
  • Blade Templates: Laravel Docs - “Blade Templates”
  • Routing: Laravel Docs - “Routing”
  • Migrations: Laravel Docs - “Migrations”

Difficulty: Advanced Time estimate: 2-4 weeks Prerequisites: Project 5. You should understand MVC before diving into a big framework.

Real world outcome: A beautiful, secure, and maintainable blog application built in a fraction of the time it took you to build it from scratch. You’ll have clean routes, expressive database queries, and powerful command-line tools at your disposal via php artisan.

Implementation Hints:

  • Follow the official Laravel Bootcamp or Laracasts videos to get started.
  • Use php artisan make:model Post -m to create a Post model and its corresponding migration file.
  • Define your database schema in the migration file. Run php artisan migrate.
  • In your PostController, instead of writing PDO queries, you’ll just use Eloquent: $posts = Post::all(); or $post = Post::findOrFail($id);.
  • Your views will be .blade.php files. You’ll create a main app.blade.php layout and extend it for different pages.

Learning milestones:

  1. You have a working Laravel application with a database migration → You’ve mastered the setup and schema management.
  2. You perform a full CRUD lifecycle using Eloquent models and a ResourceController → You are thinking in terms of the framework’s conventions.
  3. You create a view using Blade layouts and loops → You understand how to separate logic and presentation cleanly.
  4. You write a custom artisan command → You are exploring the power of the framework’s tooling and have become a true Laravel developer.

Project 7: A Real-time Chat with Asynchronous PHP

  • File: LEARN_PHP_DEEP_DIVE.md
  • Main Programming Language: PHP
  • Coolness Level: Level 5: Pure Magic (Super Cool)
  • Business Potential: 3. The “Service & Support” Model
  • Difficulty: Level 4: Expert
  • Knowledge Area: Asynchronous Programming / WebSockets
  • Software or Tool: Swoole, Workerman, or ReactPHP
  • Main Book: N/A, library documentation is key.

What you’ll build: A simple web-based chat application. Unlike a typical PHP app, this will be powered by a long-running PHP script on the server that maintains persistent WebSocket connections with all clients.

Why it teaches PHP: This project shatters the “request-response-die” model and shows what PHP is capable of in the world of asynchronous, event-driven programming. You will learn about event loops, coroutines, and managing state in a long-lived application, which are completely different from traditional PHP development.

Core challenges you’ll face:

  • Breaking the request-response model → maps to writing a PHP script that runs forever as a server daemon
  • Handling WebSockets → maps to managing connection open/message/close events
  • Managing state for all connected clients → maps to storing connection objects in an array or hash map without a global $_SESSION to rely on
  • Asynchronous I/O → maps to understanding event loops and non-blocking operations

Key Concepts:

  • Event Loop: The core of async programming.
  • WebSockets: A protocol providing full-duplex communication channels over a single TCP connection.
  • Coroutines/Fibers: A way to write asynchronous code that looks synchronous (available in Swoole and as of PHP 8.1, natively).

Difficulty: Expert Time estimate: 2-3 weeks Prerequisites: Strong PHP OOP skills, basic JavaScript for the client-side.

Real world outcome: A web page where multiple users can open it, enter a username, and chat with each other in real time, with messages appearing instantly for everyone without refreshing the page.

Implementation Hints:

  • Pick a library: Swoole is very popular and performant (requires a C extension), while ReactPHP is written in pure PHP and might be easier to start with.
  • Your server script will look very different from a web script: 
    // Example with ReactPHP
$server = new Ratchet\App('localhost', 8080);
$server->route('/chat', new MyChat, ['*']);
$server->run();
  
class MyChat implements MessageComponentInterface {
    public function onOpen(ConnectionInterface $conn) { ... }
    public function onMessage(ConnectionInterface $from, $msg) { ... }
    public function onClose(ConnectionInterface $conn) { ... }
    public function onError(ConnectionInterface $conn, \Exception $e) { ... }
}
  • You will need to maintain a pool of connected clients. When you receive a message from one client, you loop through all other clients in the pool and send them the message.
  • The client-side will be a small amount of JavaScript using the WebSocket API to connect to your PHP server.

Learning milestones:

  1. Your PHP server script can accept a WebSocket connection from a browser → You have a working event loop.
  2. The server can echo back a message sent from a client → You’ve handled the onMessage event.
  3. A message sent by one client is broadcast to all other connected clients → You are managing shared state in a long-running application.
  4. You understand the fundamental difference in memory management and state between a traditional PHP-FPM app and a long-running async app → You have unlocked a new dimension of PHP development.

Summary

Project Difficulty Time Main Concept Key Tools
1. Contact Form Beginner Hours $_POST, Form Handling Raw PHP
2. Blog with DB Intermediate 1-2 weeks PDO, SQL Injection PDO, MySQL
3. User Auth Intermediate 1-2 weeks Sessions, Hashing $_SESSION
4. Modernize w/ Composer Intermediate Weekend Autoloading, PSR-4 Composer
5. MVC Framework Advanced 2-3 weeks MVC, Routing OOP PHP
6. Blog with Laravel Advanced 2-4 weeks ORM, Templating Laravel
7. Real-time Chat Expert 2-3 weeks Async, WebSockets Swoole/ReactPHP