Modern PHP Tactics That Actually Matter in 2026

PHP has changed a lot since the days of loose arrays and mysql_query(). If you are still running code the way you wrote it in 2015, you are leaving performance, safety, and developer sanity on the table. Here is what I actually reach for in 2026, and what I think is overhyped.

Stop Writing PHP Like It Is 2015

The single biggest upgrade most codebases can make is not a framework switch. It is using the type system the language has been building since PHP 7. Typed properties, union types, and readonly have been stable for years now, and they catch real bugs before your users do.

final class Invoice
{
 public function __construct(
 public readonly int $id,
 public readonly string $customerEmail,
 public readonly int $amountCents,
 public readonly DateTimeImmutable $issuedAt,
 ) {}
}

Constructor property promotion plus readonly means you cannot accidentally reassign an invoice amount halfway through a request. That is not a style preference. That is a category of bug that simply stops existing.

Enums Replaced a Lot of My Constant Classes

Before PHP 8.1, order status lived in a class full of const strings and a comment telling everyone not to typo them. Enums fix that properly, and backed enums let you keep a database-friendly value while working with a real type in code.

enum OrderStatus: string
{
 case Pending = 'pending';
 case Paid = 'paid';
 case Shipped = 'shipped';
 case Refunded = 'refunded';

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

The match expression is strict by default, which matters. Unlike a switch, a missing case throws instead of silently falling through. I have watched that catch a real bug in production code more than once.

Fibers and Async: Know When You Actually Need Them

Fibers landed in PHP 8.1 and they are genuinely useful, but only if you understand what they are. A Fiber is a low-level primitive for pausing and resuming execution. It is not a magic async switch. It is the foundation that libraries like ReactPHP and AMPHP build on top of.

$fiber = new Fiber(function (): void {
 $value = Fiber::suspend('waiting');
 echo "Resumed with: {$value}n";
});

$fiber->start(); // prints nothing, suspends
$fiber->resume('done'); // prints "Resumed with: done"

For a typical WordPress site or a small business web app, you do not need fibers. You need to stop making blocking HTTP calls in a loop. If you are building something that talks to five external APIs per request, an event loop library is worth the learning curve. Otherwise, skip it and keep your code boring.

Attributes Beat Docblock Annotations

Docblock annotations were always a hack. They lived in comments, so your IDE and runtime treated them as text until a library parsed them. Attributes are real syntax, and the ecosystem has largely moved over.

#[Route('/invoices/{id}', methods: ['GET'])]
public function show(int $id): Response
{
 // ...
}

If you are maintaining an older Symfony or Doctrine project, check whether your annotations can be migrated. The tooling exists and the payoff is better static analysis.

What I Would Not Bother With

• Chasing every new release for its own sake. Upgrade when a feature solves a problem you have, not because a version number went up.
• Micro-optimizing before profiling. Enable OPcache and JIT where it fits, then measure. Guessing at bottlenecks wastes afternoons.
• Rewriting a working app to prove a point. I have seen more value from adding strict types to an existing codebase than from a full rewrite.

Where This Fits in Real Projects

Most of the work I do for clients around Commack and the rest of Long Island is not greenfield. It is taking an existing site or internal tool and making it faster, safer, and easier to maintain. That usually means incremental changes: add types, replace constant classes with enums, move blocking calls off the critical path. If you are weighing a rebuild against a targeted cleanup, that is exactly the kind of decision I help with through custom web development work.

FAQ

Do I need to be on PHP 8.3 or newer to use any of this?

Enums and readonly properties need 8.1 or later. Fibers also start at 8.1. If you are stuck on 7.4, the upgrade path is worth planning for, because 7.4 stopped getting security fixes a while ago.

Is JIT worth turning on for a normal website?

For most request-per-page web apps, the gain is small. JIT helps most with CPU-heavy work like math or long-running processes. Turn it on, measure, and keep it only if you see a real difference.

Should I rewrite my old code in a modern style all at once?

No. Add strict types file by file, introduce enums where you touch status logic anyway, and let the cleanup ride along with normal feature work. Big-bang rewrites break more than they fix.