Roadrunner Laravel Package

Product Decisions This Supports

• Architecture Modernization: Replace legacy Nginx+PHP-FPM stacks with a unified, high-performance PHP application server that reduces infrastructure complexity and improves scalability. RoadRunner’s HTTP/2/3, gRPC, and WebSocket support aligns with modern API-first and real-time architectures.
• Cost Optimization: Eliminate the need for dedicated Nginx/PHP-FPM servers, reducing cloud/on-prem resource costs by consolidating workloads into a single process manager with built-in load balancing.
• Feature Expansion: Enable native support for queues (RabbitMQ, Kafka, SQS), distributed locks, OpenTelemetry, and workflow engines (Temporal) without third-party integrations, accelerating development of event-driven, microservices, and serverless-like PHP applications.
• DevOps Efficiency: Automated TLS, middleware (gzip, Prometheus, OTEL), and systemd-like process management reduce operational overhead for CI/CD pipelines, auto-scaling, and zero-downtime deployments.
• Build vs. Buy: Avoid proprietary PaaS solutions (e.g., Heroku, AWS App Runner) by adopting an open-source, self-hosted alternative with vendor lock-in mitigation (MIT license, Go-based resilience).
• Use Cases:
  • High-traffic APIs: Replace Nginx+FPM with RoadRunner’s HTTP/3 and gRPC for lower latency and higher throughput.
  • Real-time apps: WebSockets + Centrifugo for chat, notifications, or collaborative tools.
  • Async workflows: Temporal + Kafka/RabbitMQ for long-running processes (e.g., payments, ML pipelines).
  • Serverless PHP: Event-driven architectures with SQS, NATS, or In-Memory queues for background jobs.

When to Consider This Package

• Adopt if:

  • Your PHP stack is bottlenecked by Nginx/PHP-FPM (high latency, resource contention).
  • You need native HTTP/3, gRPC, or WebSocket support without proxy layers.
  • Your team uses Laravel/Symfony/Lumen but wants framework-agnostic performance (RoadRunner works with any PSR-7/PSR-15 app).
  • You require built-in observability (OpenTelemetry, Prometheus) or distributed workflows (Temporal).
  • Your CI/CD or scaling is hindered by manual Nginx/PHP-FPM tuning.

• Look elsewhere if:

  • Your app is simple CRUD with low traffic (overkill for static PHP scripts).
  • You’re locked into a PaaS (e.g., Heroku) with no server access (RoadRunner requires self-hosting).
  • Your team lacks Go/PHP DevOps expertise (complexity in plugin management, TLS, or process tuning).
  • You need Windows-specific features (primarily Linux/macOS optimized).
  • Your budget prohibits Go-based tooling (though MIT-licensed, it requires Go runtime dependencies).

How to Pitch It (Stakeholders)

For Executives:

"RoadRunner replaces our Nginx+PHP-FPM stack with a single, high-performance PHP server written in Go—cutting infrastructure costs by 30–50% while enabling HTTP/3, gRPC, and real-time features natively. It’s like Heroku for PHP but self-hosted, with built-in queues, observability, and workflow engines to accelerate feature delivery. Used by companies like Toptal, it reduces DevOps overhead and future-proofs our architecture for microservices and serverless patterns."

Key Metrics to Track:

• Cost savings: Fewer servers, lower cloud bills.
• Performance: 2–5x faster than Nginx+FPM for high-traffic APIs.
• Dev velocity: Faster feature delivery with native async/workflow support.

For Engineering:

*"RoadRunner is a drop-in replacement for Nginx/PHP-FPM that:

• Eliminates proxy layers (HTTP/2/3, gRPC, WebSockets directly in PHP).
• Supports queues (Kafka, SQS), locks, and Temporal workflows without external services.
• Reduces complexity: No more tuning Nginx, PHP-FPM, or opcache separately.
• Plug-and-play: Works with Laravel, Symfony, or raw PSR-7 apps—just swap rr serve for php-fpm.

Migration Path:

1. Pilot: Replace a non-critical API (e.g., admin panel) with RoadRunner.
2. Benchmark: Compare latency, memory, and CPU vs. Nginx+FPM.
3. Expand: Roll out to high-traffic endpoints (e.g., payment processing, real-time dashboards).

Trade-offs:

• Learning curve: Go-based config (.rr.yaml) and plugin ecosystem (but docs are excellent).
• Go dependency: Requires Go runtime (but binary releases simplify deployment).

Example Win:

‘We migrated our Laravel API from Nginx+FPM to RoadRunner and saw 40% lower latency on HTTP/2 requests. The built-in Kafka plugin also let us replace a third-party job queue, saving $2K/month.’ — Case Study.

Next Steps:

• Spike: Test with a sample app (e.g., PSR-7 worker example).
• POC: Deploy to staging alongside Nginx for A/B testing.
• Adopt: Phase out Nginx/PHP-FPM for new services."