Vapor Core Laravel Package

Technical Evaluation

Architecture Fit

• Serverless-First Laravel: The package is a core runtime layer for Laravel Vapor, enabling seamless integration with AWS Lambda while preserving Laravel’s ecosystem (e.g., Eloquent, Queues, Caching). It abstracts serverless complexities (cold starts, concurrency, event sources) behind familiar Laravel patterns, making it ideal for teams already using Laravel.
• Event-Driven & Async Workloads: Optimized for SQS queues, webhooks, and background jobs, reducing boilerplate for async workflows. The package handles Lambda event parsing (API Gateway, SQS, etc.), enabling zero-config event-driven architectures.
• Multi-Region & Global Scalability: Designed for AWS’s global infrastructure, with built-in support for CloudFront, Lambda@Edge, and ElastiCache. Enables low-latency deployments without manual region management.
• Octane Compatibility: Supports Laravel Octane for high-performance APIs, reducing cold starts and improving concurrency. Critical for latency-sensitive applications (e.g., real-time dashboards, trading platforms).

Integration Feasibility

• Laravel-Centric: Built for Laravel 11–13.x, with minimal friction for existing Laravel apps. The vapor-core package integrates via service providers, requiring only:
  • composer require laravel/vapor-core
  • Configuration in config/vapor.php (if needed).
• AWS Lambda Runtime: Replaces traditional PHP-FPM with a Lambda-optimized runtime, handling:
  • Request/response lifecycle (API Gateway, ALB).
  • Environment isolation (per-invocation bootstrapping).
  • AWS context (e.g., Lambda execution ID, memory limits).
• Database & Storage: Supports RDS Proxy, ElastiCache, and S3-compatible storage (e.g., MinIO) out of the box. Mitigates common serverless challenges like connection pooling and timeouts.
• CI/CD & Deployment: Integrates with Vapor’s vapor.yml for GitHub Actions/GitLab CI pipelines, enabling zero-downtime deployments via AWS CodeDeploy.

Technical Risk

Key Questions for TPM

1. Traffic Patterns:

   • Are requests spiky (e.g., marketing campaigns) or steady-state? Spiky workloads benefit most from serverless auto-scaling.
   • What’s the p99 latency requirement? If <500ms, Octane + Provisioned Concurrency may be needed.

2. State Management:

   • How are sessions, caches, and filesystem storage currently handled? Vapor requires stateless designs (e.g., Redis for sessions, S3 for files).

3. Async Workloads:

   • What percentage of logic is event-driven (e.g., queues, webhooks)? Vapor simplifies SQS, EventBridge, and webhook integrations.

4. Team Skills:

   • Does the team have AWS Lambda experience? If not, budget for training or hire a serverless specialist.
   • Is Laravel Octane already in use? If not, evaluate the migration effort for high-performance APIs.

5. Cost Sensitivity:

   • What’s the current monthly AWS bill? Serverless can reduce costs for idle workloads but may increase costs for high-volume, long-running processes.
   • Are there reserved capacity needs (e.g., 24/7 APIs)? Consider Provisioned Concurrency or Fargate hybrids.

6. Multi-Region Needs:

   • Are users global? Vapor supports multi-region deployments via CloudFront and Route 53, but latency testing is critical.

7. Compliance & Security:

   • Are there data residency requirements (e.g., GDPR)? Vapor supports region-specific deployments.
   • How is IAM managed? Vapor uses AWS IAM roles, requiring proper least-privilege policies.

8. Migration Strategy:

   • What’s the phased rollout plan? Start with non-critical endpoints, then expand to background jobs and real-time features.
   • How will legacy infrastructure (e.g., EC2) be deprecated? Use feature flags and canary deployments.

Integration Approach

Stack Fit

• Core Stack Compatibility:

  • Laravel 11–13.x: Officially supported (see changelog for Laravel 12/13 compatibility).
  • PHP 8.1–8.4: Required for Lambda runtime (Vapor’s Docker image uses PHP 8.2 by default).
  • AWS Lambda: Runtime is custom-built for Laravel, handling:
    • API Gateway (REST/HTTP APIs).
    • ALB (Application Load Balancer).
    • SQS/EventBridge (async events).
  • Octane: Optional but recommended for high-performance APIs (reduces cold starts).
  • Databases: RDS Proxy, Aurora, or ElastiCache (serverless-compatible).
  • Storage: S3, EFS, or S3-compatible (e.g., MinIO).
  • Caching: Redis/ElastiCache (avoid file-based caching).

• Non-Compatible Stacks:

  • Legacy PHP (<8.1): Requires upgrade.
  • Non-AWS Clouds: Vendor-locked to AWS (though abstractions mitigate this).
  • Stateful Apps: File-based sessions, local storage, or non-RDS databases need refactoring.

Migration Path