🛠️ PHP Development Environment

The PHP Development Stack

To serve a dynamic PHP page, a few programs cooperate. A browser sends an HTTP request to a web server, which hands PHP files to the PHP interpreter; the interpreter often reads and writes a database, then returns HTML that the web server sends back.

Two ways PHP connects to a web server

In production, PHP usually runs as PHP-FPM (FastCGI Process Manager) behind Nginx, or as an Apache module. For local development you can skip all of that — PHP ships a built-in server that needs zero configuration.

Three Ways to Set Up

There's no single "right" way to install PHP. Pick the approach that matches your goals and comfort level.

All-in-one packages at a glance

Fastest Start: the Built-in Server

You may not need Apache or Nginx locally at all. Once PHP is installed, its built-in web server runs any folder as a site in one command. First, install PHP:

# macOS (Homebrew)
brew install php

# Ubuntu / Debian
sudo apt update
sudo apt install php php-cli php-mysql php-mbstring php-xml php-curl

# Windows: download the zip from windows.php.net, unzip to C:\php,
# then add C:\php to your PATH. (Laragon/XAMPP do this for you.)

# Confirm the version (expect 8.3.x or 8.4.x)
php --version

Now serve a folder. Create index.php, then start the server:

<?php
// index.php
echo '<h1>PHP is running!</h1>';
echo '<p>Version: ' . phpversion() . '</p>';
phpinfo(); // full configuration report

# From the folder containing index.php:
php -S localhost:8000

# Open http://localhost:8000 in your browser

The Docker Approach

Docker packages PHP, the web server, and the database into containers that behave identically on every machine. It eliminates "works on my computer" problems and mirrors production closely. Here's a compact stack — PHP 8.3 with Apache, MySQL, and phpMyAdmin:

# compose.yaml  (run with: docker compose up -d)
services:
  web:
    image: php:8.3-apache
    ports:
      - "8080:80"
    volumes:
      - ./:/var/www/html
    depends_on:
      - db

  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: app
      MYSQL_USER: dev
      MYSQL_PASSWORD: devpass
    volumes:
      - db_data:/var/lib/mysql

  phpmyadmin:
    image: phpmyadmin
    ports:
      - "8081:80"
    environment:
      PMA_HOST: db
    depends_on:
      - db

volumes:
  db_data:

With that file in your project folder:

# Start the whole stack in the background
docker compose up -d

# Your app:        http://localhost:8080
# phpMyAdmin:      http://localhost:8081

# Add PHP extensions inside the image via a Dockerfile:
#   RUN docker-php-ext-install pdo_mysql

# Stop and remove containers
docker compose down

Configuring php.ini

The php.ini file controls how PHP behaves — error display, memory limits, upload sizes, time zone, and more. PHP ships two templates: php.ini-development (verbose errors, for you) and php.ini-production (quiet and hardened, for servers).

First, find which file is actually loaded:

# Show the loaded configuration file
php -i | grep "Loaded Configuration File"

# Or, in a browser, create a page with <?php phpinfo(); ?>
# and read the "Loaded Configuration File" row.

Settings that matter for development

A minimal development block looks like this:

; --- Development settings in php.ini ---
display_errors = On
display_startup_errors = On
error_reporting = E_ALL
log_errors = On
error_log = /tmp/php-error.log
date.timezone = "America/New_York"

Extensions

Extra capabilities (database drivers, image processing, etc.) come from extensions. Common ones: pdo_mysql, mbstring, curl, gd, zip, intl. Enable them in php.ini or install them per platform:

# Ubuntu/Debian
sudo apt install php-mysql php-mbstring php-gd

# In a Dockerfile
RUN docker-php-ext-install pdo_mysql gd

VS Code for PHP

A tuned editor turns PHP from "type and pray" into a guided experience with autocompletion, instant error highlighting, and jump-to-definition. VS Code is free, fast, and — with a couple of extensions — an excellent PHP environment. PhpStorm is the powerful paid alternative if you prefer a full IDE.

After installing, point VS Code at your PHP binary so it can validate and run code. Open Settings and set:

// settings.json
{
  "php.validate.executablePath": "/usr/bin/php",
  "intelephense.environment.phpVersion": "8.3.0",
  "editor.formatOnSave": true
}

On Windows the path is typically C:\\php\\php.exe or, with Laragon, something like C:\\laragon\\bin\\php\\php-8.3\\php.exe.

Real Debugging with Xdebug

Sprinkling var_dump() and echo everywhere works, but it's slow and messy. Xdebug lets you set a breakpoint, pause execution on that exact line, and inspect every variable in scope — the way a professional debugs.

Basic debugging you already have

<?php
$user = ['name' => 'Ada', 'roles' => ['admin']];

var_dump($user);   // type + value, great for arrays/objects
print_r($user);    // human-readable structure
error_log('reached checkout step'); // write to the error log

Setting up Xdebug

1. Install it: sudo apt install php-xdebug (Linux), pecl install xdebug (macOS), or enable the bundled DLL in XAMPP/Laragon on Windows.
2. Configure it in php.ini:

[xdebug]
zend_extension=xdebug
xdebug.mode=debug
xdebug.start_with_request=yes
xdebug.client_port=9003
xdebug.client_host=localhost

3. Add a launch configuration so VS Code listens for Xdebug. Create .vscode/launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Listen for Xdebug",
      "type": "php",
      "request": "launch",
      "port": 9003
    }
  ]
}

Press F5, click in the gutter to set a breakpoint, then load your page. Execution stops on that line and the sidebar shows every variable.

Hands-on Exercise

<?php
// info.php
phpinfo();

Summary & Quiz

📚 Further Reading

• PHP Manual — Installation & Configuration
• Xdebug Documentation
• VS Code — PHP Development
• Official PHP Docker images

🚀 What's Next?

Your workshop is ready. The one tool we mentioned but haven't set up is Composer — PHP's dependency manager. Next you'll learn to pull in third-party libraries, autoload your own classes, and manage versions like a pro.