Modern PHP is not the PHP you remember, explained simply

If you last touched PHP around 2010, you're walking into a completely different language today. Modern PHP is not the PHP you remember, explained simply: it now ships with strict typing, enums, a JIT compiler, and frameworks like Laravel that let you build anything from APIs to real-time applications with the same confidence you'd have in Go or Node.js. We've spent years shipping production systems in PHP, and the gap between the old days and now is enormous.

The transformation started in earnest with PHP 7.0 in 2015, but PHP 8 in 2020 was the inflection point. Type hints moved from optional nice-to-have to a first-class language feature. Performance jumped dramatically. The ecosystem matured. Today, PHP powers roughly 77% of all websites with a known server-side language, and a huge chunk of that is running modern, type-safe, well-architected code.

Strict types, enums and readonly properties

The biggest culture shift in modern PHP is types everywhere. In the old days, you'd pass strings around and hope they stayed strings. Today, you declare what you expect, and PHP enforces it at runtime.

Let's look at strict types in action. When you add this at the top of a file:

declare(strict_types=1);

You're telling PHP: enforce type coercion rules strictly. No surprises. A function that expects an int and receives a string will throw a TypeError instead of silently converting. This catches bugs before they hit production.

declare(strict_types=1);

function calculateDiscount(int $percentageOff, float $price): float
{
    return $price * (1 - $percentageOff / 100);
}

// This works
echo calculateDiscount(20, 99.99); // 79.992

// This throws TypeError: Argument 1 must be of type int, string given
calculateDiscount('20', 99.99);

Union types (PHP 8.0) and intersection types (PHP 8.1) let you express more complex contracts:

function processPayment(int|string $amount): bool|null
{
    // Handle both int and string amounts
    $normalized = is_int($amount) ? $amount : (int)$amount;
    return $normalized > 0 ? true : null;
}

Enums arrived in PHP 8.1 and are genuinely game-changing for domain modeling. Instead of scattered string constants, you get type-safe enumeration:

enum OrderStatus: string
{
    case PENDING = 'pending';
    case CONFIRMED = 'confirmed';
    case SHIPPED = 'shipped';
    case DELIVERED = 'delivered';
    case CANCELLED = 'cancelled';

    public function isTerminal(): bool
    {
        return match($this) {
            self::DELIVERED, self::CANCELLED => true,
            default => false,
        };
    }
}

$status = OrderStatus::SHIPPED;

if ($status->isTerminal()) {
    // can't transition from here
}

Readonly properties (PHP 8.1) prevent accidental mutation of immutable data:

class User
{
    public readonly string $id;
    public readonly string $email;

    public function __construct(string $id, string $email)
    {
        $this->id = $id;
        $this->email = $email;
    }
}

$user = new User('abc-123', 'team@example.com');
$user->email = 'other@example.com'; // Error: Cannot modify readonly property

We use these features in every application we build now. They're not optional. They catch entire categories of bugs at development time, not in production at 3 AM.

Fast runtime with opcache and JIT

Performance used to be PHP's biggest weakness. That's simply no longer true.

OPcache, which became the default in PHP 5.5, compiles PHP scripts into bytecode and caches it. You're not re-parsing the same file on every request. When properly configured (and it should be), OPcache alone gives you 3–5x throughput improvement over raw interpretation.

But PHP 8 added JIT (Just-In-Time) compilation, which takes hot code paths and compiles them to machine code. Real, native code. We've seen CPU usage drop by 30–40% on identical workloads when enabling JIT on production systems.

Here's what a typical PHP 8 configuration looks like in php.ini for production:

[opcache]
opcache.enable=1
opcache.enable_cli=0
opcache.memory_consumption=256
opcache.interned_strings_buffer=16
opcache.max_accelerated_files=20000
opcache.validate_timestamps=0

[jit]
opcache.jit=tracing
opcache.jit_buffer_size=100M

The tracing mode is a good middle ground—it profiles the code, identifies hot paths, and compiles only what matters. The result: your Laravel app can now handle 2–3x the concurrent requests on the same hardware.

We run benchmarks regularly, and modern PHP with these settings is competitive with Node.js for I/O-bound workloads and often beats it on CPU-bound tasks. It's not a theoretical improvement; this is what we ship to production.

Laravel and Symfony for serious apps

A framework is where philosophy meets productivity. Laravel and Symfony represent two schools: Laravel prioritizes developer happiness and rapid iteration; Symfony prioritizes flexibility and architectural purity.

Laravel dominates the PHP ecosystem right now, and for good reason. A basic CRUD API takes minutes, not hours:

// routes/api.php
Route::apiResource('orders', OrderController::class);

// app/Http/Controllers/OrderController.php
class OrderController extends Controller
{
    public function index(): JsonResponse
    {
        return response()->json(Order::with('customer')->paginate());
    }

    public function store(StoreOrderRequest $request): JsonResponse
    {
        $order = Order::create($request->validated());
        return response()->json($order, 201);
    }
}

But Laravel also scales to complex applications. We've built real-time trading platforms, ride-hailing systems, and multi-tenant SaaS products in Laravel. The framework provides:

• Type-safe queries through Eloquent ORM with strict typing
• Background jobs with Redis, SQS, or database drivers
• WebSocket support via Laravel Echo and Pusher or Socket.io
• Testing infrastructure built-in with Pest and PHPUnit
• Dependency injection with automatic resolution and binding
• Middleware pipeline for request/response filtering

Symfony is heavier but more modular. You can use Symfony components in isolation—routing, validation, serialization—or embrace the full framework. It's the choice when you need architectural flexibility or integration with complex legacy systems.

Both ship with modern tooling: migrations, seeders, validation, authentication, authorization. Both have rich package ecosystems. Both can talk to Redis, Kafka, and message queues as easily as a database.

Powers a huge share of the web

PHP runs 77% of websites with a known server-side language. That includes WordPress, Shopify, Facebook's original codebase (before Hack), and thousands of production applications at scale.

What does "at scale" mean? We're talking:

• E-commerce platforms processing millions in transactions daily
• Travel and hospitality systems handling global inventory and bookings
• SaaS applications with thousands of paying customers
• CRM systems managing complex business logic and integrations
• Real-time platforms using WebSockets and event-driven architectures

The reason: PHP is pragmatic. It has a shallow learning curve, a massive talent pool, and exceptional tooling for web development specifically. You can hire. You can scale. You can maintain it for years.

Modern PHP also integrates seamlessly with infrastructure we all use: Docker, Kubernetes, Redis, PostgreSQL, Kafka, AWS. It's not an island language; it plays well with others.

Common mistakes

As you move to modern PHP, watch out for these:

• Ignoring strict types—Don't skip declare(strict_types=1). It's a one-line safety net that catches entire classes of bugs.
• Not configuring OPcache in production—If you're running PHP without OPcache, you're leaving 50% of performance on the table. Check your php.ini now.
• Treating Laravel as "just for startups"—Modern Laravel is production-hardened. Teams at Slack, GitHub, and major financial firms use it. It's not a limitation.
• Over-using nullable types—?string $value is sometimes necessary, but lean toward non-nullable types and explicit error handling. It forces clearer thinking.
• Not running tests—PHP's dynamic nature means tests aren't optional. Pest and PHPUnit are excellent; use them from day one.

Key takeaways

• PHP 8 brought strict typing, enums, and readonly properties—transforming PHP from a loosely-typed scripting language into a modern, type-safe system.
• OPcache and JIT compilation make modern PHP competitive on performance; properly configured, it handles 2–3x the concurrency of older versions.
• Laravel and Symfony are production-grade frameworks used by major companies; they're not starter projects—they're full-featured platforms for building anything.
• PHP still powers 77% of websites for good reason: pragmatism, scalability, talent availability, and deep integration with web infrastructure.
• Modern PHP requires a different mindset than legacy PHP: embrace types, run tests, configure the runtime properly, and use frameworks designed for the 2020s.