Backend Development: Laravel, Node.js, Go, Django, PostgreSQL

On production server at 3:14 AM, Laravel Jobs queue stopped processing. 40,000 unhandled tasks in Redis. Cause: worker crashed due to memory leak in one Job (leak through static variable in Eloquent observer), supervisor didn't restart it due to misconfigured stopwaitsecs. This is not hypothetical scenario — this is Tuesday.

Backend is what works when nobody watches. Or doesn't work.

Laravel: From Project Structure to Production

Laravel is our primary framework for business applications. Versions 10 and 11, PHP 8.2+.

What's Done Right From Day One

Service Layer above Fat Controllers. Controller receives HTTP request, validates via Form Request, passes data to Service, returns response. Business logic in Service, not Controller. Sounds trivial, but most legacy projects — 500-line controllers with SQL inside.

Repository Pattern — carefully. Often overused in Laravel. If you just wrap Model::where(...) in repository method — that's boilerplate without benefit. Repository justified when: need to abstract from data source (DB + cache + external API) or query logic complex enough for isolation.

Jobs, Events, Listeners. Everything doable asynchronously — do async. Email sending, PDF generation, external API sync, aggregate recalculation — in Queue. Laravel Horizon for queue monitoring in Redis: see throughput, failed jobs, processing time per queue.

Octane for high load. Laravel Octane with RoadRunner or Swoole keeps application in memory between requests — removes bootstrap overhead (config loading, class autoloading) per HTTP request. Gain: 3–8x on synthetic benchmarks, 2–4x on real applications. Important: can't store state between requests in static variables — leads exactly to incidents like start.

N+1: Detect, Don't Fix Post-Hoc

N+1 is most common cause of slow pages in Laravel apps. Standard story: page works fine in dev with 10 records, production with 10,000 — 8-second load.

Laravel Debugbar in dev shows query count per page. Over 20 queries per page — signal for audit.

preventLazyLoading() in AppServiceProvider (dev mode):

Model::preventLazyLoading(! app()->isProduction());

Any lazy load throws exception in dev — forces thinking about eager loading upfront.

Telescope for staging profiling: logs all requests, jobs, mail, notifications with time details.

PostgreSQL: Indexes That Really Matter

PostgreSQL 14+ is primary DB on all projects.

Indexes Often Forgotten

Composite indexes for common WHERE + ORDER BY. If you have WHERE user_id = ? AND status = ? ORDER BY created_at DESC — need (user_id, status, created_at DESC). Index on (user_id) alone doesn't help with sorting.

Partial indexes. If 95% of queries go with WHERE status = 'active':

CREATE INDEX idx_orders_active ON orders (created_at DESC)
WHERE status = 'active';

Index is small, fast, covers main load.

GIN-indexes for JSONB and arrays. Storing metadata in JSONB? @> operator without GIN-index — seq scan. With index — fast even on millions of records.

GIN for full-text search. to_tsvector + GIN instead of LIKE '%query%'. LIKE without index — always seq scan. With pg_trgm extension and gin_trgm_ops — LIKE support with index, useful for CRM partial name search.

Connection Pooling

Rails, Laravel, Django open new PostgreSQL connection per PHP/Python process. On 100 workers — 100 connections. PostgreSQL degrades from 200–300 active connections — management overhead becomes significant.

PgBouncer — connection pooler before PostgreSQL. Transaction pooling mode: PostgreSQL connection occupied only during transaction, returned to pool between requests. 1000 app workers → 20–50 real PostgreSQL connections.

Node.js with Fastify: When It's Better Than Laravel

Node.js justified for:

• Realtime: WebSocket servers, Server-Sent Events, chat, live updates
• Streaming: large files, video, data streams
• High I/O concurrency: many parallel external API requests without heavy business logic
• Serverless: Lambda/Cloud Functions — Node.js starts faster

Fastify instead of Express: 2–3x faster on benchmarks, built-in JSON Schema validation, better TypeScript support, plugin architecture.

Typical realtime architecture: Laravel — main business logic and REST API. Node.js + Socket.io or ws — WebSocket server. Laravel publishes events to Redis Pub/Sub, Node.js subscribes and broadcasts to clients. Allows scaling WebSocket server independently from main app.

Go: Microservices and High Load

We use Go for:

• High-load microservices (> 10,000 RPS)
• Background workers with strict latency requirements
• DevOps tools and CLI
• gRPC services in microservice architecture

Goroutines — thousand times cheaper than OS threads. 10,000 concurrent connections on Go — normal on one server.

But Go is not magic bullet. Development slower than Laravel: more boilerplate, no ORM like Eloquent, error handling via if err != nil everywhere. Justified only when performance is real requirement, not assumption.

Django and Python Backend

Django with DRF (Django REST Framework) — for tasks needing Python: ML pipelines, data processing, AI tool integrations.

Celery for background tasks — like Laravel Queue, but more complex config. Celery Beat for cron tasks.

Django ORM vs raw SQL: ORM convenient for CRUD. For analytical queries with multiple JOINs, window functions, CTEs — connection.execute() with raw SQL more readable and predictable.

Redis: More Than Cache

Redis in our projects serves several roles:

Redis Cluster for horizontal scaling. Sentinel for automatic failover on standalone setups.

Deploy and Infrastructure

Docker + docker-compose — standard for local dev and production. Each service in container: PHP-FPM/Octane, Nginx, PostgreSQL, Redis, Queue Worker, Scheduler.

CI/CD via GitHub Actions:

1. Run tests (PHPUnit / Pest, Vitest, Playwright)
2. Build Docker image
3. Push to Container Registry
4. Deploy: docker pull → docker-compose up -d on server, or Kubernetes rolling update

Zero-downtime deploy for Laravel: php artisan down --secret=TOKEN not needed with proper setup. Strategy: new container starts beside old, Nginx switches traffic after health check, old container stops.

Monitoring: Sentry for exception tracking with alerting to Slack/Telegram. Grafana + Prometheus (or Grafana Cloud) for metrics: CPU, memory, request rate, queue depth, database connection count. Alerts on: error rate > 1%, p99 latency > 2s, queue depth > 1000 jobs.

Timeline Guidelines

Cost calculated individually after analyzing load requirements, integrations, and business logic.