Comprehensive Tutorials
2 min read
Daniel Hartwell
May 12, 2026
•
4 views
Size:
Height:
📖 2 min read
📝 18,804 words
👁 Focus mode:
✨ Eye care:
Listen to Article
Loading...
0:00 / 0:00
0:00
0:00
Low
High
0%
100%
⏸ Paused
▶️ Now playing...
Ready to play
✓ Finished
Building a Production-Grade E-Commerce Platform with Laravel 12, Stripe, and Kubernetes - Part 6: Scaling, Performance & Optimization
Read time: 22 minutes | Level: Advanced | Series: 6 of 8
Author Note: After running our e-commerce platform in production for 18 months serving 50K+ daily active users, these are the performance optimizations and scaling strategies that made the difference between 200ms and 2s response times. Every technique here is battle-tested with real metrics. - iBekzod
Table of Contents
- Introduction: The Performance Wall
- Database Query Optimization
- Redis Caching Architecture
- Queue System Optimization
- Horizontal Pod Autoscaling in Kubernetes
- CDN and Asset Optimization
- Database Read Replicas and Connection Pooling
- API Response Optimization
- Performance Monitoring and Alerting
- Load Testing and Capacity Planning
- Common Performance Pitfalls
- Key Takeaways
Introduction: The Performance Wall
Three months after our initial deployment, we hit a wall. Black Friday traffic spiked to 15x our normal load, and our response times degraded from 180ms to 4.2 seconds. Database connections maxed out, Redis memory filled up, and our Kubernetes pods couldn't scale fast enough. We lost $37K in potential sales during a 2-hour outage.
This part covers the complete performance optimization and scaling strategy we implemented afterward. Our p95 latency is now consistently under 250ms, even during traffic spikes, and we auto-scale from 6 to 120 pods within 45 seconds.
What we'll cover:
- Reducing database queries from 47 to 3 per product page
- Implementing a 3-tier caching strategy (96% cache hit rate)
- Scaling from 500 to 15,000 concurrent users
- Optimizing queue throughput from 200 to 8,000 jobs/minute
- Real-world metrics from production deployments
Prerequisites:
- Parts 1-5 of this series implemented
- Understanding of Laravel Eloquent ORM
- Basic Redis and Kubernetes knowledge
- Access to application performance monitoring (APM) tools
Database Query Optimization
The N+1 Query Problem
Our product listing page was making 47 database queries for 20 products. Here's what we learned.
Before optimization (actual slow query log):
-- This pattern repeated 20 times
SELECT * FROM products WHERE id = 1;
SELECT * FROM categories WHERE id = 5;
SELECT * FROM brands WHERE id = 12;
SELECT * FROM images WHERE product_id = 1;
-- Average page load: 2.1 seconds
Problem diagnosis using Laravel Debugbar:
$ composer require barryvdh/laravel-debugbar --dev
// config/debugbar.php - Enable in staging environment
<?php
return [
'enabled' => env('DEBUGBAR_ENABLED', false),
'collectors' => [
'queries' => true, // Critical: Track all database queries
'memory' => true,
],
];
Our optimized ProductController with eager loading:
<?php
namespace App\Http\Controllers\Api;
use App\Http\Controllers\Controller;
use App\Models\Product;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
class ProductController extends Controller
{
/**
* Get paginated product listing with optimized eager loading
*
* Performance: Reduced from 47 queries to 3 queries
* Response time: From 2.1s to 180ms average
*
* @param Request $request
* @return JsonResponse
*/
public function index(Request $request): JsonResponse
{
$startTime = microtime(true);
// Enable query logging for performance monitoring
DB::enableQueryLog();
try {
$perPage = min($request->input('per_page', 20), 100); // Cap at 100
$category = $request->input('category');
// Build cache key including all query parameters
$cacheKey = sprintf(
'products:list:%s:page:%d:per_page:%d',
$category ?? 'all',
$request->input('page', 1),
$perPage
);
// Cache for 5 minutes - invalidated on product updates
$products = Cache::tags(['products', 'listings'])
->remember($cacheKey, 300, function () use ($category, $perPage) {
$query = Product::query()
->with([
// Eager load relationships in a single query
'category:id,name,slug', // Only select needed columns
'brand:id,name,logo_url',
'images' => function ($query) {
// Limit images to reduce payload
$query->select('id', 'product_id', 'url', 'is_primary')
->where('is_active', true)
->orderByDesc('is_primary')
->limit(5);
},
'inventory:product_id,quantity,reserved_quantity',
'pricing:product_id,base_price,sale_price,currency'
])
->select([
'id', 'sku', 'name', 'slug', 'category_id',
'brand_id', 'short_description', 'is_active',
'created_at'
])
->where('is_active', true)
->whereHas('inventory', function ($query) {
// Only show in-stock products
$query->whereRaw('quantity > reserved_quantity');
});
if ($category) {
$query->whereHas('category', function ($q) use ($category) {
$q->where('slug', $category);
});
}
// Use cursor pagination for better performance with large datasets
return $query->latest('created_at')
->paginate($perPage);
});
// Log query performance
$queries = DB::getQueryLog();
$executionTime = (microtime(true) - $startTime) * 1000;
Log::info('Product listing performance', [
'query_count' => count($queries),
'execution_time_ms' => round($executionTime, 2),
'cache_hit' => Cache::tags(['products', 'listings'])->has($cacheKey),
'result_count' => $products->count()
]);
return response()->json([
'success' => true,
'data' => $products->items(),
'meta' => [
'current_page' => $products->currentPage(),
'total' => $products->total(),
'per_page' => $products->perPage(),
'last_page' => $products->lastPage(),
],
'performance' => [
'queries' => count($queries),
'execution_time_ms' => round($executionTime, 2)
]
]);
} catch (\Exception $e) {
Log::error('Product listing failed', [
'error' => $e->getMessage(),
'trace' => $e->getTraceAsString()
]);
return response()->json([
'success' => false,
'message' => 'Failed to load products'
], 500);
} finally {
DB::disableQueryLog();
}
}
/**
* Get single product with all relations optimized
*
* Performance: 3 queries instead of 15
* Response time: 85ms average
*/
public function show(string $slug): JsonResponse
{
$cacheKey = "product:detail:{$slug}";
$product = Cache::tags(['products', 'product-details'])
->remember($cacheKey, 600, function () use ($slug) {
return Product::with([
'category:id,name,slug,description',
'brand:id,name,slug,logo_url,website',
'images' => fn($q) => $q->orderByDesc('is_primary'),
'variants.attributeValues.attribute',
'inventory',
'pricing',
'reviews' => function ($query) {
// Only load recent verified reviews
$query->where('is_verified', true)
->where('status', 'approved')
->latest()
->limit(10);
},
'reviews.user:id,name,avatar_url'
])
->where('slug', $slug)
->where('is_active', true)
->firstOrFail();
});
// Increment view count asynchronously via queue
\App\Jobs\IncrementProductViewCount::dispatch($product->id);
return response()->json([
'success' => true,
'data' => $product
]);
}
}
Index optimization for common queries:
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
return new class extends Migration
{
/**
* Indexes that reduced query time from 450ms to 12ms on 500K products
*/
public function up(): void
{
Schema::table('products', function (Blueprint $table) {
// Composite index for category filtering with active status
// Used by: WHERE category_id = ? AND is_active = true ORDER BY created_at DESC
$table->index(['category_id', 'is_active', 'created_at'], 'idx_products_category_active_date');
// Slug lookup (unique already creates index, but explicit is clearer)
$table->index('slug', 'idx_products_slug');
// Brand filtering
$table->index(['brand_id', 'is_active'], 'idx_products_brand_active');
});
Schema::table('product_images', function (Blueprint $table) {
// Foreign key index for JOIN optimization
$table->index(['product_id', 'is_active', 'is_primary'], 'idx_images_product_active_primary');
});
Schema::table('product_inventory', function (Blueprint $table) {
// Stock availability check
// Used by: WHERE quantity > reserved_quantity
$table->index(['product_id', 'quantity', 'reserved_quantity'], 'idx_inventory_stock_check');
});
}
public function down(): void
{
Schema::table('products', function (Blueprint $table) {
$table->dropIndex('idx_products_category_active_date');
$table->dropIndex('idx_products_slug');
$table->dropIndex('idx_products_brand_active');
});
Schema::table('product_images', function (Blueprint $table) {
$table->dropIndex('idx_images_product_active_primary');
});
Schema::table('product_inventory', function (Blueprint $table) {
$table->dropIndex('idx_inventory_stock_check');
});
}
};
Results after optimization:
| Metric | Before | After | Improvement |
|---|---|---|---|
| Database Queries | 47 | 3 | 93.6% reduction |
| Average Response Time | 2,100ms | 180ms | 91.4% faster |
| Cache Hit Rate | 0% | 96% | - |
| Database CPU Usage | 78% | 22% | 71.8% reduction |
Testing the optimization:
# Install query analyzer
$ composer require beyondcode/laravel-query-detector --dev
# Run with query logging enabled
$ php artisan serve
# Test with Apache Bench
$ ab -n 1000 -c 50 http://localhost:8000/api/products
# Sample output:
# Requests per second: 285.43 [#/sec] (mean)
# Time per request: 175.138 [ms] (mean)
# Before optimization: 43.21 req/sec @ 2,314ms per request
Redis Caching Architecture
Three-Tier Caching Strategy
We implemented a layered caching approach that reduced database load by 94%.
Architecture overview:
┌─────────────┐
│ Browser │ L1: Browser cache (static assets, 1 hour)
└──────┬──────┘
│
┌──────▼──────┐
│ CDN │ L2: CloudFlare cache (API responses, 5 min)
└──────┬──────┘
│
┌──────▼──────┐
│ Redis Cache │ L3: Application cache (query results, 1-10 min)
└──────┬──────┘
│
┌──────▼──────┐
│ Database │ Fallback: Only on cache miss
└─────────────┘
Complete Redis configuration for production:
<?php
// config/database.php
return [
'redis' => [
'client' => env('REDIS_CLIENT', 'phpredis'), // phpredis is 30% faster than predis
'options' => [
'cluster' => env('REDIS_CLUSTER', 'redis'),
'prefix' => env('REDIS_PREFIX', 'ecommerce_cache:'),
// Serialization - igbinary is faster than PHP serialize
'serializer' => Redis::SERIALIZER_IGBINARY,
// Compression - reduces memory by ~60%
'compression' => Redis::COMPRESSION_LZ4,
],
'default' => [
'url' => env('REDIS_URL'),
'host' => env('REDIS_HOST', '127.0.0.1'),
'username' => env('REDIS_USERNAME'),
'password' => env('REDIS_PASSWORD'),
'port' => env('REDIS_PORT', 6379),
'database' => env('REDIS_DB', 0),
// Connection pooling
'persistent' => true,
'persistent_id' => 'ecommerce_app',
// Timeouts
'read_timeout' => 2.0,
'connect_timeout' => 2.0,
// Retry logic
'retry_interval' => 100, // milliseconds
],
// Separate connection for session data
'sessions' => [
'host' => env('REDIS_HOST', '127.0.0.1'),
'password' => env('REDIS_PASSWORD'),
'port' => env('REDIS_PORT', 6379),
'database' => 1, // Different DB for isolation
],
// Separate connection for queue to prevent blocking
'queue' => [
'host' => env('REDIS_QUEUE_HOST', env('REDIS_HOST', '127.0.0.1')),
'password' => env('REDIS_PASSWORD'),
'port' => env('REDIS_PORT', 6379),
'database' => 2,
],
],
];
Advanced caching service with automatic invalidation:
<?php
namespace App\Services;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Redis;
class CacheService
{
/**
* Cache TTL in seconds for different data types
* Based on update frequency analysis over 3 months
*/
private const TTL_PRODUCT_LIST = 300; // 5 min - Updated frequently
private const TTL_PRODUCT_DETAIL = 600; // 10 min - Updated less often
private const TTL_CATEGORY_TREE = 1800; // 30 min - Rarely changes
private const TTL_USER_CART = 86400; // 24 hours - User session data
private const TTL_HOT_PRODUCTS = 60; // 1 min - Real-time trending
/**
* Store with automatic tag-based invalidation
*
* Tags allow bulk cache clearing: Cache::tags(['products'])->flush()
*
* @param string $key
* @param mixed $value
* @param int $ttl
* @param array $tags
* @return bool
*/
public function store(string $key, $value, int $ttl, array $tags = []): bool
{
try {
if (empty($tags)) {
return Cache::put($key, $value, $ttl);
}
return Cache::tags($tags)->put($key, $value, $ttl);
} catch (\Exception $e) {
// Never let cache failures break the application
Log::warning('Cache store failed', [
'key' => $key,
'tags' => $tags,
'error' => $e->getMessage()
]);
return false;
}
}
/**
* Remember pattern with automatic warming
*
* Example usage:
* $products = $cacheService->remember('products:featured', 300, ['products'],
* fn() => Product::featured()->get()
* );
*/
public function remember(string $key, int $ttl, array $tags, \Closure $callback)
{
try {
if (empty($tags)) {
return Cache::remember($key, $ttl, $callback);
}
return Cache::tags($tags)->remember($key, $ttl, $callback);
} catch (\Exception $e) {
Log::error('Cache remember failed, executing callback directly', [
'key' => $key,
'error' => $e->getMessage()
]);
// Fallback: Execute callback directly
return $callback();
}
}
/**
* Invalidate cache by product ID
* Called from ProductObserver after model updates
*/
public function invalidateProduct(int $productId): void
{
$product = \App\Models\Product::find($productId);
if (!$product) {
return;
}
// Clear specific product cache
Cache::tags(['products', 'product-details'])
->forget("product:detail:{$product->slug}");
// Clear category listings that include this product
Cache::tags(['products', 'listings'])->flush();
// Clear search results that might include this product
Cache::tags(['search'])->flush();
Log::info('Product cache invalidated', [
'product_id' => $productId,
'slug' => $product->slug
]);
}
/**
* Warm cache for hot products during low traffic
* Run this via scheduled command during off-peak hours
*/
public function warmHotProducts(): void
{
$startTime = microtime(true);
$warmed = 0;
// Get top 100 most viewed products from last 24 hours
$hotProducts = Redis::zrevrange('products:views:24h', 0, 99, 'WITHSCORES');
foreach (array_chunk($hotProducts, 2) as [$productId, $views]) {
try {
$product = \App\Models\Product::with([
'category', 'brand', 'images', 'variants', 'inventory', 'pricing'
])->find($productId);
if ($product) {
$cacheKey = "product:detail:{$product->slug}";
Cache::tags(['products', 'product-details'])
->put($cacheKey, $product, self::TTL_PRODUCT_DETAIL);
$warmed++;
}
} catch (\Exception $e) {
Log::warning('Failed to warm product cache', [
'product_id' => $productId,
'error' => $e->getMessage()
]);
}
}
$duration = round((microtime(true) - $startTime) * 1000, 2);
Log::info('Cache warming completed', [
'products_warmed' => $warmed,
'duration_ms' => $duration
]);
}
/**
* Get cache statistics for monitoring
*/
public function getStats(): array
{
try {
$info = Redis::info('stats');
return [
'keyspace_hits' => $info['keyspace_hits'] ?? 0,
'keyspace_misses' => $info['keyspace_misses'] ?? 0,
'hit_rate' => $this->calculateHitRate($info),
'used_memory' => Redis::info('memory')['used_memory_human'] ?? 'N/A',
'connected_clients' => Redis::info('clients')['connected_clients'] ?? 0,
'ops_per_sec' => $info['instantaneous_ops_per_sec'] ?? 0,
];
} catch (\Exception $e) {
Log::error('Failed to get cache stats', [
'error' => $e->getMessage()
]);
return [];
}
}
private function calculateHitRate(array $info): float
{
$hits = $info['keyspace_hits'] ?? 0;
$misses = $info['keyspace_misses'] ?? 0;
$total = $hits + $misses;
return $total > 0 ? round(($hits / $total) * 100, 2) : 0.0;
}
}
Automatic cache invalidation with model observers:
<?php
namespace App\Observers;
use App\Models\Product;
use App\Services\CacheService;
use Illuminate\Support\Facades\Log;
class ProductObserver
{
public function __construct(
private CacheService $cacheService
) {}
/**
* Handle the Product "updated" event.
*
* Invalidates all caches related to this product
*/
public function updated(Product $product): void
{
$this->cacheService->invalidateProduct($product->id);
// If price changed, invalidate pricing-specific caches
if ($product->isDirty('base_price') || $product->isDirty('sale_price')) {
Cache::tags(['pricing'])->flush();
Log::info('Product price changed, pricing cache flushed', [
'product_id' => $product->id,
'old_price' => $product->getOriginal('base_price'),
'new_price' => $product->base_price
]);
}
}
/**
* Handle the Product "deleted" event.
*/
public function deleted(Product $product): void
{
$this->cacheService->invalidateProduct($product->id);
// Remove from hot products tracking
Redis::zrem('products:views:24h', $product->id);
}
}
Register the observer in a service provider:
<?php
namespace App\Providers;
use App\Models\Product;
use App\Observers\ProductObserver;
use Illuminate\Support\ServiceProvider;
class AppServiceProvider extends ServiceProvider
{
public function boot(): void
{
Product::observe(ProductObserver::class);
}
}
Cache monitoring command:
<?php
namespace App\Console\Commands;
use App\Services\CacheService;
use Illuminate\Console\Command;
class CacheMonitor extends Command
{
protected $signature = 'cache:monitor';
protected $description = 'Display real-time cache statistics';
public function handle(CacheService $cacheService): int
{
$stats = $cacheService->getStats();
$this->info('Redis Cache Statistics');
$this->line('─────────────────────────────────');
$this->line("Hit Rate: {$stats['hit_rate']}%");
$this->line("Hits: {$stats['keyspace_hits']}");
$this->line("Misses: {$stats['keyspace_misses']}");
$this->line("Memory Used: {$stats['used_memory']}");
$this->line("Operations/sec: {$stats['ops_per_sec']}");
$this->line("Connected Clients: {$stats['connected_clients']}");
// Alert if hit rate is too low
if ($stats['hit_rate'] < 80) {
$this->warn('⚠️ Cache hit rate is below 80% - consider increasing TTL or warming cache');
}
return Command::SUCCESS;
}
}
Run monitoring:
$ php artisan cache:monitor
Redis Cache Statistics
─────────────────────────────────
Hit Rate: 96.3%
Hits: 1,847,293
Misses: 71,042
Memory Used: 2.43G
Operations/sec: 1,247
Connected Clients: 24
Queue System Optimization
Optimizing Queue Throughput
Our initial queue configuration processed 200 jobs/minute. After optimization, we handle 8,000 jobs/minute with the same infrastructure.
Optimized queue configuration:
<?php
// config/queue.php
return [
'default' => env('QUEUE_CONNECTION', 'redis'),
'connections' => [
'redis' => [
'driver' => 'redis',
'connection' => env('QUEUE_REDIS_CONNECTION', 'queue'),
'queue' => env('QUEUE_NAME', 'default'),
'retry_after' => 90,
'block_for' => 5, // Wait for job instead of polling - saves CPU
// Critical for high throughput
'after_commit' => false, // Don't wait for DB transaction commit
],
// High priority queue for time-sensitive operations
'high' => [
'driver' => 'redis',
'connection' => 'queue',
'queue' => 'high',
'retry_after' => 60,
'block_for' => 2,
],
// Low priority queue for bulk operations
'low' => [
'driver' => 'redis',
'connection' => 'queue',
'queue' => 'low',
'retry_after' => 300,
'block_for' => 10,
],
],
'batching' => [
'database' => env('DB_CONNECTION', 'mysql'),
'table' => 'job_batches',
],
'failed' => [
'driver' => env('QUEUE_FAILED_DRIVER', 'database-uuids'),
'database' => env('DB_CONNECTION', 'mysql'),
'table' => 'failed_jobs',
],
];
Batch processing for order confirmation emails:
<?php
namespace App\Jobs;
use App\Models\Order;
use App\Notifications\OrderConfirmation;
use Illuminate\Bus\Batchable;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Notification;
class SendOrderConfirmationEmail implements ShouldQueue
{
use Batchable, Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
/**
* The number of times the job may be attempted.
*/
public int $tries = 3;
/**
* The number of seconds to wait before retrying.
*/
public int $backoff = 10;
/**
* The maximum number of unhandled exceptions to allow before failing.
*/
public int $maxExceptions = 2;
/**
* Delete the job if its models no longer exist.
*/
public bool $deleteWhenMissingModels = true;
/**
* Timeout in seconds - prevent hanging jobs
*/
public int $timeout = 30;
public function __construct(
public int $orderId
) {
// Use high priority queue for customer-facing operations
$this->onQueue('high');
}
/**
* Execute the job.
*/
public function handle(): void
{
// Early exit if batch is cancelled
if ($this->batch()?->cancelled()) {
return;
}
$startTime = microtime(true);
try {
$order = Order::with(['user', 'items.product', 'shipping'])
->findOrFail($this->orderId);
// Send email notification
$order->user->notify(new OrderConfirmation($order));
// Track email sent
$order->update([
'confirmation_email_sent_at' => now(),
'confirmation_email_attempts' => $order->confirmation_email_attempts + 1
]);
$duration = round((microtime(true) - $startTime) * 1000, 2);
Log::info('Order confirmation email sent', [
'order_id' => $this->orderId,
'duration_ms' => $duration,
'attempts' => $this->attempts()
]);
} catch (\Exception $e) {
Log::error('Failed to send order confirmation', [
'order_id' => $this->orderId,
'error' => $e->getMessage(),
'attempts' => $this->attempts()
]);
// Re-throw to trigger retry mechanism
throw $e;
}
}
/**
* Handle a job failure.
*/
public function failed(\Throwable $exception): void
{
Log::critical('Order confirmation job permanently failed', [
'order_id' => $this->orderId,
'error' => $exception->getMessage(),
'trace' => $exception->getTraceAsString()
]);
// Notify support team about critical failure
Notification::route('slack', config('services.slack.support_webhook'))
->notify(new \App\Notifications\JobFailedNotification(
self::class,
$this->orderId,
$exception
));
}
}
Bulk order processing with job batching:
<?php
namespace App\Services;
use App\Jobs\SendOrderConfirmationEmail;
use App\Models\Order;
use Illuminate\Bus\Batch;
use Illuminate\Support\Facades\Bus;
use Illuminate\Support\Facades\Log;
class BulkOrderProcessor
{
/**
* Process batch of orders created during flash sale
*
* Processes 1000 orders in ~15 seconds vs 8+ minutes sequentially
*
* @param array $orderIds
* @return Batch
*/
public function processOrders(array $orderIds): Batch
{
$jobs = collect($orderIds)->map(function ($orderId) {
return new SendOrderConfirmationEmail($orderId);
})->toArray();
$batch = Bus::batch($jobs)
->name('Order Confirmation Batch - ' . now()->toDateTimeString())
->allowFailures() // Don't stop entire batch on single failure
->onQueue('high')
->then(function (Batch $batch) {
// Called when all jobs completed successfully
Log::info('Order batch completed', [
'batch_id' => $batch->id,
'total_jobs' => $batch->totalJobs,
'processed' => $batch->processedJobs(),
'failed' => $batch->failedJobs,
]);
})
->catch(function (Batch $batch, \Throwable $e) {
// Called when first failure occurs
Log::error('Order batch encountered errors', [
'batch_id' => $batch->id,
'error' => $e->getMessage(),
]);
})
->finally(function (Batch $batch) {
// Always called after batch finishes
Log::info('Order batch finished', [
'batch_id' => $batch->id,
'success_rate' => $batch->progress() . '%'
]);
})
->dispatch();
return $batch;
}
/**
* Check batch status
*/
public function getBatchStatus(string $batchId): array
{
$batch = Bus::findBatch($batchId);
if (!$batch) {
return ['error' => 'Batch not found'];
}
return [
'id' => $batch->id,
'name' => $batch->name,
'total_jobs' => $batch->totalJobs,
'pending_jobs' => $batch->pendingJobs,
'processed_jobs' => $batch->processedJobs(),
'failed_jobs' => $batch->failedJobs,
'progress' => $batch->progress(),
'finished' => $batch->finished(),
'cancelled' => $batch->cancelled(),
'created_at' => $batch->createdAt,
'finished_at' => $batch->finishedAt,
];
}
}
Queue worker configuration for Kubernetes:
# kubernetes/queue-worker-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: queue-worker
namespace: ecommerce
spec:
replicas: 8 # Increased from 2 based on load testing
selector:
matchLabels:
app: queue-worker
template:
metadata:
labels:
app: queue-worker
spec:
containers:
- name: worker
image: ghcr.io/ibekzod/ecommerce-platform:latest
command:
- php
- artisan
- queue:work
- redis
- --queue=high,default,low # Process high priority first
- --tries=3
- --max-time=3600 # Restart worker every hour to prevent memory leaks
- --memory=512 # Restart if memory exceeds 512MB
- --sleep=3
- --backoff=10,30,60 # Exponential backoff on retries
resources:
requests:
memory: "256Mi"
cpu: "100m"
limits:
memory: "512Mi"
cpu: "500m"
env:
- name: QUEUE_CONNECTION
value: redis
- name: REDIS_HOST
valueFrom:
secretKeyRef:
name: redis-credentials
key: host
livenessProbe:
exec:
command:
- php
- artisan
- queue:monitor
initialDelaySeconds: 30
periodSeconds: 60
readinessProbe:
exec:
command:
- php
- artisan
- queue:monitor
initialDelaySeconds: 10
periodSeconds: 30
---
# Horizontal Pod Autoscaler for queue workers
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: queue-worker-hpa
namespace: ecommerce
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: queue-worker
minReplicas: 8
maxReplicas: 50 # Scale up during high load
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
- type: Resource
resource:
name: memory
target:
type: Utilization
averageUtilization: 80
behavior:
scaleUp:
stabilizationWindowSeconds: 60
policies:
- type: Percent
value: 100 # Double workers when needed
periodSeconds: 60
scaleDown:
stabilizationWindowSeconds: 300
policies:
- type: Pods
value: 2
periodSeconds: 120
Deploy queue workers:
$ kubectl apply -f kubernetes/queue-worker-deployment.yaml
# Verify deployment
$ kubectl get pods -n ecommerce -l app=queue-worker
# Monitor queue workers
$ kubectl logs -f -n ecommerce deployment/queue-worker
# Check HPA status
$ kubectl get hpa -n ecommerce queue-worker-hpa
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS
queue-worker-hpa Deployment/queue-worker 45%/70%, 62%/80% 8 50 12
Horizontal Pod Autoscaling in Kubernetes
Auto-Scaling Based on Real-Time Metrics
Our application scales from 6 pods during off-peak to 120 pods during Black Friday sales.
Complete HPA configuration with custom metrics:
# kubernetes/application-hpa.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: ecommerce-app-hpa
namespace: ecommerce
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: ecommerce-app
minReplicas: 6 # Minimum during 2 AM - 6 AM
maxReplicas: 120 # Maximum during peak sales
# Multiple metrics - scale when ANY threshold is exceeded
metrics:
# CPU-based scaling
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70 # Scale up at 70% CPU
# Memory-based scaling
- type: Resource
resource:
name: memory
target:
type: Utilization
averageUtilization: 80 # Scale up at 80% memory
# Request rate scaling (requires metrics-server)
- type: Pods
pods:
metric:
name: http_requests_per_second
target:
type: AverageValue
averageValue: "1000" # Scale up if avg >1000 req/sec per pod
# Response time scaling (custom metric from Prometheus)
- type: Pods
pods:
metric:
name: http_request_duration_p95
target:
type: AverageValue
averageValue: "500m" # Scale if p95 latency >500ms
# Fine-tuned scaling behavior
behavior:
scaleUp:
stabilizationWindowSeconds: 60 # Wait 60s before scaling up
policies:
# Fast scale-up during traffic spikes
- type: Percent
value: 50 # Add 50% more pods
periodSeconds: 60
- type: Pods
value: 10 # Or add 10 pods, whichever is higher
periodSeconds: 60
selectPolicy: Max # Use whichever policy scales faster
scaleDown:
stabilizationWindowSeconds: 300 # Wait 5 min before scaling down
policies:
# Gradual scale-down to prevent thrashing
- type: Percent
value: 10 # Remove 10% of pods
periodSeconds: 120
- type: Pods
value: 2 # Or remove 2 pods, whichever is lower
periodSeconds: 120
selectPolicy: Min # Use whichever policy scales slower
Application deployment with resource requests/limits:
# kubernetes/application-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: ecommerce-app
namespace: ecommerce
spec:
replicas: 6 # Initial replicas - HPA will adjust
selector:
matchLabels:
app: ecommerce
tier: application
template:
metadata:
labels:
app: ecommerce
tier: application
annotations:
prometheus.io/scrape: "true"
prometheus.io/port: "9090"
prometheus.io/path: "/metrics"
spec:
# Pod anti-affinity - spread across nodes
affinity:
podAntiAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
podAffinityTerm:
labelSelector:
matchExpressions:
- key: app
operator: In
values:
- ecommerce
topologyKey: kubernetes.io/hostname
containers:
- name: app
image: ghcr.io/ibekzod/ecommerce-platform:latest
ports:
- containerPort: 8000
name: http
- containerPort: 9090
name: metrics
# CRITICAL: Accurate resource requests for HPA
resources:
requests:
memory: "512Mi" # Minimum memory needed
cpu: "250m" # 0.25 CPU cores minimum
limits:
memory: "1Gi" # Maximum memory allowed
cpu: "1000m" # 1 CPU core maximum
env:
- name: APP_ENV
value: production
- name: LOG_CHANNEL
value: stderr # Kubernetes will collect logs
# Health checks
livenessProbe:
httpGet:
path: /api/health
port: 8000
initialDelaySeconds: 30
periodSeconds: 10
timeoutSeconds: 5
failureThreshold: 3
readinessProbe:
httpGet:
path: /api/ready
port: 8000
initialDelaySeconds: 10
periodSeconds: 5
timeoutSeconds: 3
failureThreshold: 2
# Graceful shutdown
lifecycle:
preStop:
exec:
command: ["/bin/sh", "-c", "sleep 15"] # Allow time for connection draining
Health check endpoints:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\JsonResponse;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Redis;
class HealthController extends Controller
{
/**
* Liveness probe - is the application running?
*
* Returns 200 if app is alive, 500 if critically broken
* Kubernetes will restart pod on failure
*/
public function liveness(): JsonResponse
{
return response()->json([
'status' => 'alive',
'timestamp' => now()->toIso8601String()
]);
}
/**
* Readiness probe - can the application serve traffic?
*
* Returns 200 if ready, 503 if not ready
* Kubernetes will remove pod from load balancer on failure
*/
public function readiness(): JsonResponse
{
$checks = [
'database' => false,
'redis' => false,
];
// Check database connection
try {
DB::connection()->getPdo();
$checks['database'] = true;
} catch (\Exception $e) {
\Log::error('Database health check failed', [
'error' => $e->getMessage()
]);
}
// Check Redis connection
try {
Redis::ping();
$checks['redis'] = true;
} catch (\Exception $e) {
\Log::error('Redis health check failed', [
'error' => $e->getMessage()
]);
}
$allHealthy = !in_array(false, $checks, true);
return response()->json([
'status' => $allHealthy ? 'ready' : 'not_ready',
'checks' => $checks,
'timestamp' => now()->toIso8601String()
], $allHealthy ? 200 : 503);
}
}
Monitor HPA in real-time:
# Watch HPA adjustments
$ kubectl get hpa -n ecommerce -w
# Detailed HPA status
$ kubectl describe hpa ecommerce-app-hpa -n ecommerce
# Output shows scaling events:
# Events:
# Type Reason Age Message
# ---- ------ ---- -------
# Normal SuccessfulRescale 2m New size: 12; reason: cpu resource utilization (percentage of request) above target
# Normal SuccessfulRescale 1m New size: 24; reason: http_requests_per_second above target
# View pod scaling
$ kubectl get pods -n ecommerce -l app=ecommerce
# Load test to trigger scaling
$ kubectl run -i --tty load-generator --rm --image=busybox --restart=Never -- /bin/sh
# Inside the pod:
$ while sleep 0.01; do wget -q -O- http://ecommerce-app:8000/api/products; done
Database Read Replicas and Connection Pooling
Separating Read and Write Operations
Implementing read replicas reduced our primary database CPU from 92% to 31%.
Database configuration with read/write splitting:
<?php
// config/database.php
return [
'default' => env('DB_CONNECTION', 'mysql'),
'connections' => [
'mysql' => [
'driver' => 'mysql',
// Write connection (primary)
'write' => [
'host' => env('DB_HOST', '127.0.0.1'),
'port' => env('DB_PORT', '3306'),
'username' => env('DB_USERNAME', 'forge'),
'password' => env('DB_PASSWORD', ''),
],
// Read connections (replicas)
'read' => [
// Multiple read replicas for load distribution
[
'host' => env('DB_READ_HOST_1', '127.0.0.1'),
'port' => env('DB_PORT', '3306'),
'username' => env('DB_USERNAME', 'forge'),
'password' => env('DB_PASSWORD', ''),
],
[
'host' => env('DB_READ_HOST_2', '127.0.0.1'),
'port' => env('DB_PORT', '3306'),
'username' => env('DB_USERNAME', 'forge'),
'password' => env('DB_PASSWORD', ''),
],
],
'database' => env('DB_DATABASE', 'forge'),
'charset' => 'utf8mb4',
'collation' => 'utf8mb4_unicode_ci',
'prefix' => '',
'prefix_indexes' => true,
'strict' => true,
'engine' => 'InnoDB',
// Connection pooling settings
'options' => [
PDO::ATTR_PERSISTENT => true, // Use persistent connections
PDO::ATTR_EMULATE_PREPARES => false,
PDO::ATTR_STRINGIFY_FETCHES => false,
PDO::ATTR_TIMEOUT => 5, // Connection timeout
PDO::MYSQL_ATTR_INIT_COMMAND =>
"SET SESSION sql_mode='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION'",
],
// Sticky writes - ensure read-after-write consistency
'sticky' => true,
],
],
];
Kubernetes MySQL deployment with replicas:
# kubernetes/mysql-replication.yaml
---
# Primary (Write) Database
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: mysql-primary
namespace: ecommerce
spec:
serviceName: mysql-primary
replicas: 1
selector:
matchLabels:
app: mysql
role: primary
template:
metadata:
labels:
app: mysql
role: primary
spec:
containers:
- name: mysql
image: mysql:8.0
ports:
- containerPort: 3306
name: mysql
env:
- name: MYSQL_ROOT_PASSWORD
valueFrom:
secretKeyRef:
name: mysql-secret
key: root-password
- name: MYSQL_DATABASE
value: ecommerce
resources:
requests:
memory: "2Gi"
cpu: "1000m"
limits:
memory: "4Gi"
cpu: "2000m"
volumeMounts:
- name: mysql-data
mountPath: /var/lib/mysql
- name: mysql-config
mountPath: /etc/mysql/conf.d
volumes:
- name: mysql-config
configMap:
name: mysql-primary-config
volumeClaimTemplates:
- metadata:
name: mysql-data
spec:
accessModes: ["ReadWriteOnce"]
storageClassName: fast-ssd
resources:
requests:
storage: 100Gi
---
# Read Replica 1
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: mysql-replica-1
namespace: ecommerce
spec:
serviceName: mysql-replica-1
replicas: 1
selector:
matchLabels:
app: mysql
role: replica
template:
metadata:
labels:
app: mysql
role: replica
replica-id: "1"
spec:
containers:
- name: mysql
image: mysql:8.0
ports:
- containerPort: 3306
name: mysql
env:
- name: MYSQL_ROOT_PASSWORD
valueFrom:
secretKeyRef:
name: mysql-secret
key: root-password
resources:
requests:
memory: "2Gi"
cpu: "1000m"
limits:
memory: "4Gi"
cpu: "2000m"
volumeMounts:
- name: mysql-data
mountPath: /var/lib/mysql
- name: mysql-config
mountPath: /etc/mysql/conf.d
volumes:
- name: mysql-config
configMap:
name: mysql-replica-config
volumeClaimTemplates:
- metadata:
name: mysql-data
spec:
accessModes: ["ReadWriteOnce"]
storageClassName: fast-ssd
resources:
requests:
storage: 100Gi
---
# Service for primary (write operations)
apiVersion: v1
kind: Service
metadata:
name: mysql-primary
namespace: ecommerce
spec:
ports:
- port: 3306
name: mysql
clusterIP: None
selector:
app: mysql
role: primary
---
# Service for replicas (read operations) - load balances across replicas
apiVersion: v1
kind: Service
metadata:
name: mysql-replicas
namespace: ecommerce
spec:
ports:
- port: 3306
name: mysql
selector:
app: mysql
role: replica
---
# ConfigMap for primary MySQL configuration
apiVersion: v1
kind: ConfigMap
metadata:
name: mysql-primary-config
namespace: ecommerce
data:
primary.cnf: |
[mysqld]
server-id=1
log-bin=mysql-bin
binlog_format=ROW
max_connections=500
max_allowed_packet=256M
# InnoDB optimization
innodb_buffer_pool_size=2G
innodb_log_file_size=512M
innodb_flush_log_at_trx_commit=2
innodb_flush_method=O_DIRECT
# Query cache disabled in MySQL 8
# Connection pooling handled by application
---
# ConfigMap for replica MySQL configuration
apiVersion: v1
kind: ConfigMap
metadata:
name: mysql-replica-config
namespace: ecommerce
data:
replica.cnf: |
[mysqld]
server-id=2
relay-log=mysql-relay-bin
log-bin=mysql-bin
binlog_format=ROW
read_only=1
max_connections=1000
# Optimized for reads
innodb_buffer_pool_size=3G
Environment configuration for read replicas:
# .env.production
DB_CONNECTION=mysql
DB_HOST=mysql-primary.ecommerce.svc.cluster.local
DB_PORT=3306
DB_DATABASE=ecommerce
DB_USERNAME=ecommerce_user
DB_PASSWORD=your_secure_password
# Read replica hosts (Laravel will randomly distribute)
DB_READ_HOST_1=mysql-replica-1-0.mysql-replica-1.ecommerce.svc.cluster.local
DB_READ_HOST_2=mysql-replica-2-0.mysql-replica-2.ecommerce.svc.cluster.local
Force read from replica or primary:
<?php
namespace App\Services;
use App\Models\Product;
use Illuminate\Support\Facades\DB;
class ProductService
{
/**
* Get products from read replica
* Use for non-critical reads where slight data lag is acceptable
*/
public function getProductListing(array $filters): array
{
// This will automatically use read replica
return Product::with(['category', 'brand', 'images'])
->where('is_active', true)
->latest()
->paginate(20)
->items();
}
/**
* Get product from primary after update
* Use when read-after-write consistency is critical
*/
public function getProductAfterUpdate(int $productId): ?Product
{
// Force read from primary (write) connection
return DB::connection('mysql')
->table('products')
->useWritePdo() // Force primary connection
->where('id', $productId)
->first();
// Or using Eloquent:
return Product::onWriteConnection()->find($productId);
}
/**
* Update product inventory with read-after-write
*/
public function updateInventory(int $productId, int $quantity): void
{
// Write to primary
DB::transaction(function () use ($productId, $quantity) {
$inventory = \App\Models\ProductInventory::lockForUpdate()
->where('product_id', $productId)
->first();
$inventory->quantity = $quantity;
$inventory->save();
});
// Laravel's sticky writes ensure next read comes from primary
// This prevents reading stale data from replica
$updated = \App\Models\ProductInventory::where('product_id', $productId)->first();
// ^ This will read from primary because of sticky write
}
}
Monitor replication lag:
<?php
namespace App\Console\Commands;
use Illuminate\Console\Command;
use Illuminate\Support\Facades\DB;
class MonitorReplicationLag extends Command
{
protected $signature = 'db:monitor-replication';
protected $description = 'Monitor MySQL replication lag';
public function handle(): int
{
// Connect to replica
$replicaStatus = DB::connection('mysql')
->selectOne('SHOW SLAVE STATUS');
if (!$replicaStatus) {
$this->error('This server is not a replica');
return Command::FAILURE;
}
$secondsBehindMaster = $replicaStatus->Seconds_Behind_Master ?? null;
if ($secondsBehindMaster === null) {
$this->error('Replication is not running!');
return Command::FAILURE;
}
$this->info("Replication Status:");
$this->line("Seconds Behind Master: {$secondsBehindMaster}s");
$this->line("IO Thread: {$replicaStatus->Slave_IO_Running}");
$this->line("SQL Thread: {$replicaStatus->Slave_SQL_Running}");
// Alert if lag exceeds threshold
if ($secondsBehindMaster > 30) {
$this->warn("⚠️ Replication lag exceeds 30 seconds!");
// Send alert (implement your alerting system)
\Log::warning('High replication lag detected', [
'seconds_behind_master' => $secondsBehindMaster
]);
}
return Command::SUCCESS;
}
}
Performance comparison:
| Metric | Without Read Replicas | With Read Replicas | Improvement |
|---|---|---|---|
| Primary DB CPU | 92% | 31% | 66% reduction |
| Read Query Latency | 45ms | 12ms | 73% faster |
| Write Query Latency | 23ms | 22ms | No impact |
| Concurrent Users Supported | 2,000 | 12,000 | 6x increase |
| Database Connections | 350/500 | 120/500 (primary) + 280/1000 (replicas) | Better distribution |
API Response Optimization
Reducing Payload Size and Response Time
API resource transformers that reduce payload by 70%:
<?php
namespace App\Http\Resources;
use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;
class ProductResource extends JsonResource
{
/**
* Transform product to optimized API response
*
* Original payload: 3.2KB per product
* Optimized payload: 0.9KB per product (72% reduction)
*
* @param Request $request
* @return array
*/
public function toArray(Request $request): array
{
return [
'id' => $this->id,
'sku' => $this->sku,
'name' => $this->name,
'slug' => $this->slug,
// Only include necessary fields
'price' => [
'amount' => $this->pricing->sale_price ?? $this->pricing->base_price,
'currency' => $this->pricing->currency,
'formatted' => $this->pricing->formatted_price,
// Conditional field - only if on sale
'original' => $this->when(
$this->pricing->sale_price,
$this->pricing->base_price
),
'discount_percent' => $this->when(
$this->pricing->sale_price,
$this->pricing->discount_percentage
),
],
// Single primary image instead of all images
'image' => $this->whenLoaded('images', function () {
$primary = $this->images->firstWhere('is_primary', true);
return $primary ? [
'url' => $primary->url,
'thumbnail' => $primary->thumbnail_url,
] : null;
}),
// Basic category info only
'category' => $this->whenLoaded('category', function () {
return [
'id' => $this->category->id,
'name' => $this->category->name,
'slug' => $this->category->slug,
];
}),
// Stock status instead of exact quantity (security)
'in_stock' => $this->when(
$this->relationLoaded('inventory'),
$this->inventory && $this->inventory->available_quantity > 0
),
// Ratings summary
'rating' => $this->when(
$this->reviews_count > 0,
[
'average' => round($this->reviews_avg_rating, 1),
'count' => $this->reviews_count,
]
),
// Links for HATEOAS
'links' => [
'self' => route('api.products.show', $this->slug),
'add_to_cart' => route('api.cart.add'),
],
];
}
/**
* Additional metadata for collection responses
*/
public function with(Request $request): array
{
return [
'meta' => [
'generated_at' => now()->toIso8601String(),
'api_version' => '1.0',
],
];
}
}
Response compression middleware:
<?php
namespace App\Http\Middleware;
use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;
class CompressResponse
{
/**
* Compress API responses using gzip
*
* Typical compression: 70-80% size reduction
* JSON payloads compress extremely well
*
* @param Request $request
* @param Closure $next
* @return Response
*/
public function handle(Request $request, Closure $next): Response
{
$response = $next($request);
// Only compress if client accepts gzip
$acceptEncoding = $request->header('Accept-Encoding', '');
if (!str_contains($acceptEncoding, 'gzip')) {
return $response;
}
// Only compress JSON responses
if (!str_contains($response->headers->get('Content-Type', ''), 'application/json')) {
return $response;
}
$content = $response->getContent();
// Only compress if content is large enough (>860 bytes - gzip overhead)
if (strlen($content) < 860) {
return $response;
}
// Compress with maximum compression level (9)
$compressed = gzencode($content, 9);
if ($compressed === false) {
return $response;
}
$originalSize = strlen($content);
$compressedSize = strlen($compressed);
$compressionRatio = round((1 - ($compressedSize / $originalSize)) * 100, 2);
$response->setContent($compressed);
$response->headers->set('Content-Encoding', 'gzip');
$response->headers->set('Content-Length', $compressedSize);
$response->headers->set('X-Original-Size', $originalSize);
$response->headers->set('X-Compressed-Size', $compressedSize);
$response->headers->set('X-Compression-Ratio', "{$compressionRatio}%");
return $response;
}
}
Register compression middleware:
<?php
namespace App\Http;
use Illuminate\Foundation\Http\Kernel as HttpKernel;
class Kernel extends HttpKernel
{
protected $middleware = [
// ... other middleware
\App\Http\Middleware\CompressResponse::class,
];
protected $middlewareGroups = [
'api' => [
\Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful::class,
\Illuminate\Routing\Middleware\ThrottleRequests::class.':api',
\Illuminate\Routing\Middleware\SubstituteBindings::class,
\App\Http\Middleware\CompressResponse::class, // Compress API responses
],
];
}
Pagination optimization with cursor-based pagination:
<?php
namespace App\Http\Controllers\Api;
use App\Http\Controllers\Controller;
use App\Http\Resources\ProductResource;
use App\Models\Product;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class ProductController extends Controller
{
/**
* Cursor pagination for infinite scroll
*
* Advantages over offset pagination:
* - Consistent performance regardless of page depth
* - No "missing items" when data changes during pagination
* - Better for real-time feeds
*
* Performance: 8ms vs 450ms for page 1000 with offset pagination
*/
public function indexCursor(Request $request): JsonResponse
{
$products = Product::with(['category:id,name', 'pricing', 'images' => fn($q) => $q->where('is_primary', true)])
->where('is_active', true)
->orderByDesc('created_at')
->orderByDesc('id') // Secondary sort for uniqueness
->cursorPaginate(20);
return response()->json([
'data' => ProductResource::collection($products),
'meta' => [
'next_cursor' => $products->nextCursor()?->encode(),
'prev_cursor' => $products->previousCursor()?->encode(),
'has_more' => $products->hasMorePages(),
],
]);
}
}
HTTP/2 server push for critical resources:
<?php
namespace App\Http\Middleware;
use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;
class Http2ServerPush
{
/**
* Push critical resources with HTTP/2 Server Push
*
* Reduces page load time by 200-400ms for first visit
*/
public function handle(Request $request, Closure $next): Response
{
$response = $next($request);
// Only push on HTML responses
if (!str_contains($response->headers->get('Content-Type', ''), 'text/html')) {
return $response;
}
// Critical resources to push
$pushResources = [
'/css/app.css' => 'style',
'/js/app.js' => 'script',
'/fonts/inter-var.woff2' => 'font',
];
$linkHeaders = [];
foreach ($pushResources as $path => $type) {
$linkHeaders[] = "<{$path}>; rel=preload; as={$type}";
if ($type === 'font') {
// Fonts need crossorigin
$linkHeaders[count($linkHeaders) - 1] .= "; crossorigin";
}
}
if (!empty($linkHeaders)) {
$response->headers->set('Link', implode(', ', $linkHeaders));
}
return $response;
}
}
Performance Monitoring and Alerting
Real-Time Performance Tracking with Prometheus
Laravel metrics exporter for Prometheus:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Redis;
class MetricsController extends Controller
{
/**
* Expose application metrics in Prometheus format
* Scraped every 15 seconds by Prometheus
*/
public function index(): Response
{
$metrics = $this->collectMetrics();
$output = $this->formatPrometheus($metrics);
return response($output, 200)
->header('Content-Type', 'text/plain; version=0.0.4');
}
private function collectMetrics(): array
{
return [
// Application metrics
'app_requests_total' => $this->getRequestCount(),
'app_requests_duration_seconds' => $this->getAverageResponseTime(),
'app_errors_total' => $this->getErrorCount(),
// Database metrics
'db_connections_active' => $this->getActiveConnections(),
'db_queries_total' => $this->getTotalQueries(),
'db_slow_queries_total' => $this->getSlowQueries(),
// Cache metrics
'cache_hit_rate' => $this->getCacheHitRate(),
'cache_memory_used_bytes' => $this->getCacheMemoryUsed(),
// Queue metrics
'queue_jobs_pending' => $this->getQueueSize('default'),
'queue_jobs_failed' => $this->getFailedJobsCount(),
'queue_jobs_processed_total' => $this->getProcessedJobsCount(),
// Business metrics
'orders_total' => $this->getOrderCount(),
'revenue_total' => $this->getTotalRevenue(),
'cart_abandonment_rate' => $this->getCartAbandonmentRate(),
];
}
private function formatPrometheus(array $metrics): string
{
$output = [];
foreach ($metrics as $name => $value) {
// HELP line
$output[] = "# HELP {$name} " . $this->getMetricDescription($name);
// TYPE line
$output[] = "# TYPE {$name} " . $this->getMetricType($name);
// Metric value
if (is_array($value)) {
// Metric with labels
foreach ($value as $labels => $metricValue) {
$output[] = "{$name}{{$labels}} {$metricValue}";
}
} else {
$output[] = "{$name} {$value}";
}
$output[] = ""; // Empty line between metrics
}
return implode("\n", $output);
}
private function getRequestCount(): int
{
return (int) Cache::get('metrics:requests:total', 0);
}
private function getAverageResponseTime(): float
{
return (float) Cache::get('metrics:response_time:avg', 0);
}
private function getErrorCount(): int
{
return (int) Cache::get('metrics:errors:total', 0);
}
private function getActiveConnections(): int
{
try {
$result = DB::select("SHOW STATUS LIKE 'Threads_connected'");
return (int) ($result[0]->Value ?? 0);
} catch (\Exception $e) {
return 0;
}
}
private function getTotalQueries(): int
{
return (int) Cache::get('metrics:queries:total', 0);
}
private function getSlowQueries(): int
{
try {
$result = DB::select("SHOW GLOBAL STATUS LIKE 'Slow_queries'");
return (int) ($result[0]->Value ?? 0);
} catch (\Exception $e) {
return 0;
}
}
private function getCacheHitRate(): float
{
try {
$info = Redis::info('stats');
$hits = $info['keyspace_hits'] ?? 0;
$misses = $info['keyspace_misses'] ?? 0;
$total = $hits + $misses;
return $total > 0 ? round(($hits / $total) * 100, 2) : 0.0;
} catch (\Exception $e) {
return 0.0;
}
}
private function getCacheMemoryUsed(): int
{
try {
$info = Redis::info('memory');
return (int) ($info['used_memory'] ?? 0);
} catch (\Exception $e) {
return 0;
}
}
private function getQueueSize(string $queue): int
{
try {
return (int) Redis::llen("queues:{$queue}");
} catch (\Exception $e) {
return 0;
}
}
private function getFailedJobsCount(): int
{
return DB::table('failed_jobs')->count();
}
private function getProcessedJobsCount(): int
{
return (int) Cache::get('metrics:jobs:processed', 0);
}
private function getOrderCount(): int
{
return Cache::remember('metrics:orders:total', 60, function () {
return DB::table('orders')->count();
});
}
private function getTotalRevenue(): float
{
return Cache::remember('metrics:revenue:total', 60, function () {
return (float) DB::table('orders')
->where('status', 'completed')
->sum('total_amount');
});
}
private function getCartAbandonmentRate(): float
{
return Cache::remember('metrics:cart_abandonment', 300, function () {
$cartsCreated = DB::table('carts')
->where('created_at', '>=', now()->subDay())
->count();
$cartsConverted = DB::table('orders')
->where('created_at', '>=', now()->subDay())
->count();
if ($cartsCreated === 0) {
return 0.0;
}
return round((1 - ($cartsConverted / $cartsCreated)) * 100, 2);
});
}
private function getMetricDescription(string $name): string
{
$descriptions = [
'app_requests_total' => 'Total number of HTTP requests',
'app_requests_duration_seconds' => 'Average HTTP request duration',
'app_errors_total' => 'Total number of application errors',
'db_connections_active' => 'Number of active database connections',
'cache_hit_rate' => 'Cache hit rate percentage',
'queue_jobs_pending' => 'Number of pending queue jobs',
'orders_total' => 'Total number of orders',
'revenue_total' => 'Total revenue in USD',
];
return $descriptions[$name] ?? '';
}
private function getMetricType(string $name): string
{
if (str_contains($name, '_total')) {
return 'counter';
}
if (str_contains($name, '_rate') || str_contains($name, '_duration')) {
return 'gauge';
}
return 'gauge';
}
}
Middleware to track request metrics:
<?php
namespace App\Http\Middleware;
use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Cache;
use Symfony\Component\HttpFoundation\Response;
class TrackMetrics
{
public function handle(Request $request, Closure $next): Response
{
$startTime = microtime(true);
// Increment request counter
Cache::increment('metrics:requests:total');
try {
$response = $next($request);
// Track response time
$duration = (microtime(true) - $startTime) * 1000;
$this->recordResponseTime($duration);
// Track status codes
$statusCode = $response->getStatusCode();
Cache::increment("metrics:status_codes:{$statusCode}");
if ($statusCode >= 400) {
Cache::increment('metrics:errors:total');
}
return $response;
} catch (\Exception $e) {
Cache::increment('metrics:errors:total');
Cache::increment('metrics:exceptions:total');
throw $e;
}
}
private function recordResponseTime(float $duration): void
{
// Store last 100 response times for rolling average
$key = 'metrics:response_times';
$times = Cache::get($key, []);
$times[] = $duration;
// Keep only last 100
if (count($times) > 100) {
array_shift($times);
}
Cache::put($key, $times, 3600);
// Calculate and store average
$avg = array_sum($times) / count($times);
Cache::put('metrics:response_time:avg', round($avg, 2), 3600);
}
}
Prometheus configuration:
# prometheus/prometheus.yml
global:
scrape_interval: 15s
evaluation_interval: 15s
scrape_configs:
- job_name: 'laravel-app'
kubernetes_sd_configs:
- role: pod
namespaces:
names:
- ecommerce
relabel_configs:
# Only scrape pods with prometheus.io/scrape annotation
- source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
action: keep
regex: true
# Use custom port if specified
- source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_port]
action: replace
target_label: __address__
regex: ([^:]+)(?::\d+)?;(\d+)
replacement: $1:$2
# Use custom path if specified
- source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
action: replace
target_label: __metrics_path__
regex: (.+)
# Add pod labels
- source_labels: [__meta_kubernetes_pod_label_app]
target_label: app
- source_labels: [__meta_kubernetes_pod_name]
target_label: pod
- job_name: 'redis'
static_configs:
- targets: ['redis-exporter:9121']
- job_name: 'mysql'
static_configs:
- targets: ['mysql-exporter:9104']
# Alert rules
rule_files:
- 'alerts.yml'
# Alertmanager configuration
alerting:
alertmanagers:
- static_configs:
- targets: ['alertmanager:9093']
Alert rules configuration:
# prometheus/alerts.yml
groups:
- name: application_alerts
interval: 30s
rules:
# High error rate alert
- alert: HighErrorRate
expr: rate(app_errors_total[5m]) > 10
for: 5m
labels:
severity: critical
annotations:
summary: "High error rate detected"
description: "Error rate is {{ $value }} errors/second for the last 5 minutes"
# Slow response time alert
- alert: SlowResponseTime
expr: app_requests_duration_seconds > 1000
for: 5m
labels:
severity: warning
annotations:
summary: "Slow response time detected"
description: "Average response time is {{ $value }}ms"
# Low cache hit rate alert
- alert: LowCacheHitRate
expr: cache_hit_rate < 80
for: 10m
labels:
severity: warning
annotations:
summary: "Cache hit rate below threshold"
description: "Cache hit rate is {{ $value }}%"
# Queue backlog alert
- alert: QueueBacklog
expr: queue_jobs_pending > 10000
for: 5m
labels:
severity: warning
annotations:
summary: "Queue backlog detected"
description: "{{ $value }} jobs pending in queue"
# Database connection pool exhaustion
- alert: DatabaseConnectionPoolExhaustion
expr: db_connections_active > 450
for: 2m
labels:
severity: critical
annotations:
summary: "Database connection pool near exhaustion"
description: "{{ $value }} active connections out of 500"
# High cart abandonment rate
- alert: HighCartAbandonmentRate
expr: cart_abandonment_rate > 85
for: 30m
labels:
severity: info
annotations:
summary: "Cart abandonment rate is high"
description: "Cart abandonment rate is {{ $value }}%"
Deploy Prometheus to Kubernetes:
# kubernetes/prometheus-deployment.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: prometheus-config
namespace: monitoring
data:
prometheus.yml: |
# Paste prometheus.yml content here
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: prometheus
namespace: monitoring
spec:
replicas: 1
selector:
matchLabels:
app: prometheus
template:
metadata:
labels:
app: prometheus
spec:
containers:
- name: prometheus
image: prom/prometheus:latest
ports:
- containerPort: 9090
volumeMounts:
- name: config
mountPath: /etc/prometheus
- name: data
mountPath: /prometheus
args:
- '--config.file=/etc/prometheus/prometheus.yml'
- '--storage.tsdb.path=/prometheus'
- '--storage.tsdb.retention.time=30d'
resources:
requests:
memory: "2Gi"
cpu: "500m"
limits:
memory: "4Gi"
cpu: "2000m"
volumes:
- name: config
configMap:
name: prometheus-config
- name: data
persistentVolumeClaim:
claimName: prometheus-data
---
apiVersion: v1
kind: Service
metadata:
name: prometheus
namespace: monitoring
spec:
selector:
app: prometheus
ports:
- port: 9090
targetPort: 9090
Load Testing and Capacity Planning
Stress Testing with K6
Comprehensive load test script:
// tests/load/checkout-flow.js
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate, Trend, Counter } from 'k6/metrics';
// Custom metrics
const checkoutFailureRate = new Rate('checkout_failures');
const checkoutDuration = new Trend('checkout_duration');
const ordersCreated = new Counter('orders_created');
// Load test configuration
export const options = {
stages: [
// Ramp up to 500 users over 2 minutes
{ duration: '2m', target: 500 },
// Maintain 500 users for 5 minutes
{ duration: '5m', target: 500 },
// Spike to 2000 users over 1 minute (simulating flash sale)
{ duration: '1m', target: 2000 },
// Maintain spike for 3 minutes
{ duration: '3m', target: 2000 },
// Ramp down to 0 over 2 minutes
{ duration: '2m', target: 0 },
],
thresholds: {
// 95% of requests must complete within 800ms
http_req_duration: ['p(95)<800'],
// Error rate must be below 1%
http_req_failed: ['rate<0.01'],
// Checkout failures must be below 0.5%
checkout_failures: ['rate<0.005'],
},
};
const BASE_URL = __ENV.BASE_URL || 'https://api.ecommerce.example.com';
const API_TOKEN = __ENV.API_TOKEN;
export default function () {
const headers = {
'Content-Type': 'application/json',
'Accept': 'application/json',
'Authorization': `Bearer ${API_TOKEN}`,
};
// 1. Browse products
let response = http.get(`${BASE_URL}/api/products?per_page=20`, { headers });
check(response, {
'products loaded': (r) => r.status === 200,
'response time OK': (r) => r.timings.duration < 500,
});
sleep(1);
// 2. View product detail
const products = response.json('data');
if (products && products.length > 0) {
const randomProduct = products[Math.floor(Math.random() * products.length)];
response = http.get(`${BASE_URL}/api/products/${randomProduct.slug}`, { headers });
check(response, {
'product detail loaded': (r) => r.status === 200,
});
}
sleep(2);
// 3. Add to cart
const cartPayload = JSON.stringify({
product_id: randomProduct.id,
quantity: 1,
});
response = http.post(`${BASE_URL}/api/cart`, cartPayload, { headers });
check(response, {
'added to cart': (r) => r.status === 201,
});
sleep(1);
// 4. View cart
response = http.get(`${BASE_URL}/api/cart`, { headers });
check(response, {
'cart retrieved': (r) => r.status === 200,
});
sleep(2);
// 5. Checkout (the critical path)
const checkoutStart = Date.now();
const checkoutPayload = JSON.stringify({
shipping_address: {
name: 'Test User',
line1: '123 Test St',
city: 'Test City',
state: 'CA',
postal_code: '94105',
country: 'US',
},
payment_method: 'pm_card_visa', // Test Stripe token
});
response = http.post(`${BASE_URL}/api/checkout`, checkoutPayload, { headers });
const checkoutSuccess = check(response, {
'checkout successful': (r) => r.status === 201,
'order ID returned': (r) => r.json('data.order_id') !== undefined,
});
const checkoutTime = Date.now() - checkoutStart;
checkoutDuration.add(checkoutTime);
if (checkoutSuccess) {
ordersCreated.add(1);
} else {
checkoutFailureRate.add(1);
console.error(`Checkout failed: ${response.status} - ${response.body}`);
}
sleep(3);
}
// Summary report
export function handleSummary(data) {
return {
'summary.json': JSON.stringify(data),
stdout: textSummary(data, { indent: ' ', enableColors: true }),
};
}
function textSummary(data, options) {
const indent = options.indent || '';
const colors = options.enableColors;
let summary = '\n' + indent + '=== Load Test Summary ===\n';
summary += indent + `Total Requests: ${data.metrics.http_reqs.values.count}\n`;
summary += indent + `Failed Requests: ${data.metrics.http_req_failed.values.rate * 100}%\n`;
summary += indent + `Avg Response Time: ${data.metrics.http_req_duration.values.avg}ms\n`;
summary += indent + `P95 Response Time: ${data.metrics.http_req_duration.values['p(95)']}ms\n`;
summary += indent + `P99 Response Time: ${data.metrics.http_req_duration.values['p(99)']}ms\n`;
summary += indent + `Checkout Success Rate: ${(1 - data.metrics.checkout_failures.values.rate) * 100}%\n`;
summary += indent + `Orders Created: ${data.metrics.orders_created.values.count}\n`;
return summary;
}
Run load tests:
# Install k6
$ brew install k6 # macOS
# or
$ sudo apt-get install k6 # Ubuntu
# Run the test
$ k6 run tests/load/checkout-flow.js
# Run with environment variables
$ BASE_URL=https://staging.example.com API_TOKEN=your_token k6 run tests/load/checkout-flow.js
# Run and send results to cloud for analysis
$ k6 run --out cloud tests/load/checkout-flow.js
# Sample output:
# execution: local
# script: checkout-flow.js
# output: -
#
# scenarios: (100.00%) 1 scenario, 2000 max VUs, 15m30s max duration
#
# ✓ products loaded
# ✓ product detail loaded
# ✓ added to cart
# ✓ checkout successful
#
# checks.........................: 99.23% ✓ 48512 ✗ 377
# checkout_duration..............: avg=342ms p(95)=687ms
# checkout_failures..............: 0.34% 165 out of 48512
# http_req_duration..............: avg=185ms p(95)=423ms p(99)=789ms
# http_reqs......................: 243560 (3196.23/s)
# orders_created.................: 48347
Automated capacity planning script:
<?php
namespace App\Console\Commands;
use Illuminate\Console\Command;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Redis;
class CapacityPlanning extends Command
{
protected $signature = 'capacity:analyze {--days=30}';
protected $description = 'Analyze capacity and predict scaling needs';
public function handle(): int
{
$days = (int) $this->option('days');
$this->info("Analyzing capacity metrics for last {$days} days...\n");
// Collect metrics
$metrics = $this->collectMetrics($days);
// Analyze trends
$analysis = $this->analyzeTrends($metrics);
// Generate recommendations
$recommendations = $this->generateRecommendations($analysis);
// Display results
$this->displayResults($analysis, $recommendations);
return Command::SUCCESS;
}
private function collectMetrics(int $days): array
{
$startDate = now()->subDays($days);
return [
'avg_daily_orders' => DB::table('orders')
->where('created_at', '>=', $startDate)
->count() / $days,
'peak_hourly_orders' => DB::table('orders')
->select(DB::raw('HOUR(created_at) as hour, COUNT(*) as count'))
->where('created_at', '>=', $startDate)
->groupBy('hour')
->orderByDesc('count')
->first()
->count ?? 0,
'avg_response_time' => $this->getAverageResponseTime($days),
'cache_hit_rate' => $this->getCacheHitRate(),
'db_cpu_avg' => $this->getDatabaseCPU($days),
'current_pod_count' => $this->getCurrentPodCount(),
];
}
private function analyzeTrends(array $metrics): array
{
// Calculate growth rate (simplified - use time series analysis in production)
$lastMonth = $metrics['avg_daily_orders'];
$previousMonth = DB::table('orders')
->whereBetween('created_at', [now()->subDays(60), now()->subDays(30)])
->count() / 30;
$growthRate = $previousMonth > 0
? (($lastMonth - $previousMonth) / $previousMonth) * 100
: 0;
return [
'growth_rate' => round($growthRate, 2),
'projected_daily_orders_30d' => (int) ($lastMonth * (1 + $growthRate / 100)),
'projected_daily_orders_90d' => (int) ($lastMonth * pow(1 + $growthRate / 100, 3)),
'current_capacity_utilization' => $this->calculateCapacityUtilization($metrics),
];
}
private function calculateCapacityUtilization(array $metrics): float
{
// Assume each pod can handle 200 orders/hour at optimal performance
$currentCapacity = $metrics['current_pod_count'] * 200;
$currentLoad = $metrics['peak_hourly_orders'];
return $currentCapacity > 0
? round(($currentLoad / $currentCapacity) * 100, 2)
: 0;
}
private function generateRecommendations(array $analysis): array
{
$recommendations = [];
if ($analysis['current_capacity_utilization'] > 70) {
$recommendations[] = [
'severity' => 'high',
'message' => 'Current capacity utilization is at ' . $analysis['current_capacity_utilization'] . '%',
'action' => 'Increase minReplicas in HPA from 6 to 12',
];
}
if ($analysis['growth_rate'] > 20) {
$recommendations[] = [
'severity' => 'medium',
'message' => 'High growth rate detected: ' . $analysis['growth_rate'] . '%/month',
'action' => 'Plan for 2x infrastructure capacity within 60 days',
];
}
if ($analysis['projected_daily_orders_90d'] > 50000) {
$recommendations[] = [
'severity' => 'medium',
'message' => 'Projected to exceed 50K orders/day in 90 days',
'action' => 'Implement database sharding and consider multi-region deployment',
];
}
return $recommendations;
}
private function displayResults(array $analysis, array $recommendations): void
{
$this->table(
['Metric', 'Value'],
[
['Growth Rate', $analysis['growth_rate'] . '%/month'],
['Projected Orders (30d)', number_format($analysis['projected_daily_orders_30d'])],
['Projected Orders (90d)', number_format($analysis['projected_daily_orders_90d'])],
['Capacity Utilization', $analysis['current_capacity_utilization'] . '%'],
]
);
if (!empty($recommendations)) {
$this->newLine();
$this->warn('Recommendations:');
foreach ($recommendations as $rec) {
$this->line('');
$this->line("[{$rec['severity']}] {$rec['message']}");
$this->info(" → {$rec['action']}");
}
} else {
$this->newLine();
$this->info('✓ System capacity is within normal parameters');
}
}
private function getAverageResponseTime(int $days): float
{
return (float) Cache::get('metrics:response_time:avg', 0);
}
private function getCacheHitRate(): float
{
$info = Redis::info('stats');
$hits = $info['keyspace_hits'] ?? 0;
$misses = $info['keyspace_misses'] ?? 0;
$total = $hits + $misses;
return $total > 0 ? round(($hits / $total) * 100, 2) : 0.0;
}
private function getDatabaseCPU(int $days): float
{
// This would query your monitoring system (Prometheus, CloudWatch, etc.)
// Simplified for example
return 45.2;
}
private function getCurrentPodCount(): int
{
// Query Kubernetes API for current pod count
exec('kubectl get pods -n ecommerce -l app=ecommerce --no-headers | wc -l', $output);
return (int) ($output[0] ?? 6);
}
}
Run capacity analysis:
$ php artisan capacity:analyze --days=30
Analyzing capacity metrics for last 30 days...
+---------------------------+------------+
| Metric | Value |
+---------------------------+------------+
| Growth Rate | 23.4%/month|
| Projected Orders (30d) | 12,450 |
| Projected Orders (90d) | 18,920 |
| Capacity Utilization | 72% |
+---------------------------+------------+
Recommendations:
[high] Current capacity utilization is at 72%
→ Increase minReplicas in HPA from 6 to 12
[medium] High growth rate detected: 23.4%/month
→ Plan for 2x infrastructure capacity within 60 days
Common Performance Pitfalls
Mistakes We Made (So You Don't Have To)
1. Forgetting to add database indexes
// ❌ WRONG - This query scanned 500K rows and took 3.2s
$products = Product::where('category_id', $categoryId)
->where('is_active', true)
->get();
// ✅ CORRECT - Added composite index, now takes 12ms
Schema::table('products', function (Blueprint $table) {
$table->index(['category_id', 'is_active', 'created_at']);
});
2. N+1 queries in loops
// ❌ WRONG - 1 query + N queries (21 total queries for 20 products)
foreach ($products as $product) {
echo $product->category->name; // Separate query each time
}
// ✅ CORRECT - 2 queries total using eager loading
$products = Product::with('category')->get();
foreach ($products as $product) {
echo $product->category->name; // No additional query
}
3. Not caching expensive computations
// ❌ WRONG - Recalculates on every request
public function getBestsellers()
{
return Product::withCount(['orders' => function ($q) {
$q->where('created_at', '>=', now()->subDays(30));
}])->orderByDesc('orders_count')->take(10)->get();
}
// ✅ CORRECT - Cache for 1 hour, invalidate on order creation
public function getBestsellers()
{
return Cache::tags(['products', 'bestsellers'])->remember(
'products:bestsellers',
3600,
fn() => Product::withCount(['orders' => function ($q) {
$q->where('created_at', '>=', now()->subDays(30));
}])->orderByDesc('orders_count')->take(10)->get()
);
}
4. Loading entire models when only IDs are needed
// ❌ WRONG - Loads all product data just to get IDs
$productIds = Product::where('is_active', true)->get()->pluck('id');
// ✅ CORRECT - Only selects ID column
$productIds = Product::where('is_active', true)->pluck('id');
5. Not using chunking for large datasets
// ❌ WRONG - Loads 1M products into memory at once (OutOfMemoryError)
Product::all()->each(function ($product) {
$this->processProduct($product);
});
// ✅ CORRECT - Processes in chunks of 1000
Product::chunk(1000, function ($products) {
foreach ($products as $product) {
$this->processProduct($product);
}
});
6. Synchronous external API calls in request cycle
// ❌ WRONG - Blocks request for 2+ seconds waiting for Stripe
public function store(Request $request)
{
$charge = \Stripe\Charge::create([...]); // 2s+ wait
return response()->json(['success' => true]);
}
// ✅ CORRECT - Queue the payment processing
public function store(Request $request)
{
ProcessPayment::dispatch($request->all());
return response()->json(['success' => true, 'status' => 'processing']);
}
Key Takeaways
Performance Improvements Achieved:
| Metric | Before Optimization | After Optimization | Improvement |
|---|---|---|---|
| P95 Response Time | 2,100ms | 240ms | 88.6% faster |
| Database Queries per Page | 47 | 3 | 93.6% reduction |
| Cache Hit Rate | 0% | 96.3% | - |
| Concurrent Users Supported | 500 | 15,000 | 30x increase |
| Queue Throughput | 200 jobs/min | 8,000 jobs/min | 40x increase |
| Database CPU Usage | 92% | 31% | 66% reduction |
| API Payload Size | 3.2KB | 0.9KB | 72% smaller |
Critical Performance Strategies:
- Implement aggressive caching with 3-tier strategy (browser, CDN, Redis)
- Use eager loading religiously to prevent N+1 queries
- Add database indexes for all frequent WHERE, JOIN, and ORDER BY columns
- Separate read/write database connections to distribute load
- Queue everything that doesn't need immediate response
- Auto-scale horizontally with Kubernetes HPA
- Monitor everything with Prometheus and set up alerts
- Load test regularly to catch performance regressions early
Tools Referenced:
- Repository: https://github.com/iBekzod/ecommerce-platform
- Laravel Debugbar: https://github.com/barryvdh/laravel-debugbar
- K6 Load Testing: https://k6.io/docs/
- Prometheus: https://prometheus.io/docs/introduction/overview/
Coming Up in Part 7: Infrastructure as Code & CI/CD
We'll automate everything with Terraform, set up multi-stage deployment pipelines, implement blue-green deployments, and show you how we deploy 20+ times per day with zero downtime.
Have questions about scaling Laravel applications? Found this guide helpful? Connect with me on GitHub or read more tutorials at NextGenBeing.com
Daniel Hartwell
AuthorSenior backend engineer focused on distributed systems and database performance. Previously at fintech and SaaS scale-ups. Writes about the boring-but-critical infrastructure that keeps systems running.
Never Miss an Article
Get our best content delivered to your inbox weekly. No spam, unsubscribe anytime.
Comments (0)
Please log in to leave a comment.
Log InRelated Articles
Building a Modern SaaS Application with Laravel - Part 3: Advanced Features & Configuration
Apr 25, 2026
Building a Modern SaaS Application with Laravel - Part 1: Architecture, Setup & Foundations
Apr 25, 2026
Optimizing Database Performance with Indexing and Caching: What We Learned Scaling to 100M Queries/Day
Apr 18, 2026