english/.opencode/skills/backend-development/references/backend-technologies.md

Backend Technologies

Core technologies, frameworks, databases, and message queues for modern backend development (2025).

Programming Languages

Node.js/TypeScript

Market Position: TypeScript dominance in Node.js backend (industry standard)

Best For:

• Full-stack JavaScript teams
• Real-time applications (WebSockets, Socket.io)
• Rapid prototyping with npm ecosystem (2M+ packages)
• Event-driven architectures

Popular Frameworks:

• NestJS - Enterprise-grade, TypeScript-first, modular architecture
• Express - Lightweight, flexible, most popular (23M weekly downloads)
• Fastify - High performance (20k req/sec vs Express 15k req/sec)
• tRPC - End-to-end typesafe APIs without GraphQL

When to Choose: Team already using JavaScript/TypeScript, real-time features needed, rapid development priority

Python

Market Position: FastAPI adoption surge - 73% migrating from Flask

Best For:

• Data-heavy applications
• ML/AI integration (TensorFlow, PyTorch)
• Scientific computing
• Scripting and automation

Popular Frameworks:

• FastAPI - Modern, async, auto-generated OpenAPI docs, validation via Pydantic
• Django - Batteries-included, ORM, admin panel, authentication
• Flask - Lightweight, flexible, microservices-friendly

When to Choose: Data science integration, ML/AI features, rapid prototyping, team Python expertise

Go

Market Position: Preferred for microservices at scale (Docker, Kubernetes written in Go)

Best For:

• High-concurrency systems (goroutines)
• Microservices architectures
• CLI tools and DevOps tooling
• System programming

Popular Frameworks:

• Gin - Fast HTTP router (40x faster than Martini)
• Echo - High performance, extensible
• Fiber - Express-like API, built on Fasthttp

When to Choose: Microservices, high concurrency needs, DevOps tooling, simple deployment (single binary)

Rust

Market Position: 72% most admired language, 1.5x faster than Go

Best For:

• Performance-critical systems
• Memory-safe system programming
• High-reliability requirements
• WebAssembly backends

Popular Frameworks:

• Axum - Ergonomic, modular, tokio-based
• Actix-web - Fastest web framework (benchmark leader)
• Rocket - Type-safe, easy to use

When to Choose: Maximum performance needed, memory safety critical, low-level control required

Databases

Relational (SQL)

PostgreSQL

Market Position: Most popular SQL database for new projects

Strengths:

• ACID compliance, data integrity
• JSON/JSONB support (hybrid SQL + NoSQL)
• Full-text search, geospatial (PostGIS)
• Advanced indexing (B-tree, Hash, GiST, GIN)
• Window functions, CTEs, materialized views

Use Cases:

• E-commerce (transactions critical)
• Financial applications
• Complex reporting requirements
• Multi-tenant applications

When to Choose: Need ACID guarantees, complex queries/joins, data integrity critical

NoSQL

MongoDB

Market Position: Leading document database

Strengths:

• Flexible/evolving schemas
• Horizontal scaling (sharding built-in)
• Aggregation pipeline (powerful data processing)
• GridFS for large files

Use Cases:

• Content management systems
• Real-time analytics
• IoT data collection
• Catalogs with varied attributes

When to Choose: Schema flexibility needed, rapid iteration, horizontal scaling required

Caching & In-Memory

Redis

Market Position: Industry standard for caching and session storage

Capabilities:

• In-memory key-value store
• Pub/sub messaging
• Sorted sets (leaderboards)
• Geospatial indexes
• Streams (event sourcing)

Performance: 10-100x faster than disk-based databases

Use Cases:

• Session storage
• Rate limiting
• Real-time leaderboards
• Job queues (Bull, BullMQ)
• Caching layer (90% DB load reduction)

When to Choose: Need sub-millisecond latency, caching layer, session management

ORMs & Database Tools

Modern ORMs (2025)

Drizzle ORM (TypeScript)

• Winning NestJS performance race
• 7.4kb, zero dependencies
• SQL-like syntax, full type safety
• Best for: Performance-critical TypeScript apps

Prisma (TypeScript)

• Auto-generated type-safe client
• Database migrations included
• Excellent DX with Prisma Studio
• Best for: Rapid development, type safety

TypeORM (TypeScript)

• Mature, feature-complete
• Supports Active Record + Data Mapper
• Best for: Complex enterprise apps

SQLAlchemy (Python)

• Industry standard Python ORM
• Powerful query builder
• Best for: Python backends

Message Queues & Event Streaming

RabbitMQ

Best For: Task queues, request/reply patterns

Strengths:

• Flexible routing (direct, topic, fanout, headers)
• Message acknowledgment and durability
• Dead letter exchanges
• Wide protocol support (AMQP, MQTT, STOMP)

Use Cases:

• Background job processing
• Microservices communication
• Email/notification queues

When to Choose: Traditional message queue needs, complex routing, moderate throughput

Apache Kafka

Best For: Event streaming, millions messages/second

Strengths:

• Distributed, fault-tolerant
• High throughput (millions msg/sec)
• Message replay (retention-based)
• Stream processing (Kafka Streams)

Use Cases:

• Real-time analytics
• Event sourcing
• Log aggregation
• Netflix/Uber scale (billions events/day)

When to Choose: Event streaming, high throughput, event replay needed, real-time analytics

Framework Comparisons

Node.js Frameworks

Framework	Performance	Learning Curve	Use Case
Express	Moderate	Easy	Simple APIs, learning
NestJS	Moderate	Steep	Enterprise apps
Fastify	High	Moderate	Performance-critical
tRPC	High	Moderate	Full-stack TypeScript

Python Frameworks

Framework	Performance	Features	Use Case
FastAPI	High	Modern, async	New projects, APIs
Django	Moderate	Batteries-included	Full-featured apps
Flask	Moderate	Minimal	Microservices, simple APIs

Technology Selection Flowchart

Start → Need real-time features?
       → Yes → Node.js + Socket.io
       → No → Need ML/AI integration?
              → Yes → Python + FastAPI
              → No → Need maximum performance?
                     → Yes → Rust + Axum
                     → No → Need high concurrency?
                            → Yes → Go + Gin
                            → No → Node.js + NestJS (safe default)

Database Selection:
ACID needed? → Yes → PostgreSQL
            → No → Flexible schema? → Yes → MongoDB
                                   → No → PostgreSQL (default)

Caching needed? → Always use Redis

Message Queue:
Millions msg/sec? → Yes → Kafka
                 → No → RabbitMQ

Common Pitfalls

1. Choosing NoSQL for relational data - Use PostgreSQL if data has clear relationships
2. Not using connection pooling - Implement pooling for 5-10x performance boost
3. Ignoring indexes - Add indexes to frequently queried columns (30% I/O reduction)
4. Over-engineering with microservices - Start monolith, split when needed
5. Not caching - Redis caching provides 90% DB load reduction

Resources

• NestJS: https://nestjs.com
• FastAPI: https://fastapi.tiangolo.com
• PostgreSQL: https://www.postgresql.org/docs/
• MongoDB: https://www.mongodb.com/docs/
• Redis: https://redis.io/docs/
• Kafka: https://kafka.apache.org/documentation/