Build production-grade, scalable backends with Rust (Axum) for high-performance services and FastAPI for Python APIs. Includes ML inference serving (ONNX, vLLM, TensorRT), event-driven architecture (Kafka, RabbitMQ, Redis), Docker/Kubernetes orchestration, and AWS deployment (ECS, EKS, Lambda). Use when building APIs, microservices, real-time systems, ML serving infrastructure, or deploying containerized applications to AWS.
Build scalable, high-performance backends using the right tool for each layer.
| Use Case | Choose | Rationale |
|---|---|---|
| High-throughput streaming | Rust/Axum | Memory efficiency, no GC pauses |
| ML inference orchestration | FastAPI | Library ecosystem, model compatibility |
| CRUD APIs, rapid prototyping | FastAPI | Development velocity |
| Sub-millisecond latency | Rust/Axum | Predictable performance |
| Data pipelines | Hybrid | Rust for hot paths, Python for orchestration |
from fastapi import FastAPI, Depends
from sqlalchemy.ext.asyncio import AsyncSession
from contextlib import asynccontextmanager
@asynccontextmanager
async def lifespan(app: FastAPI):
# Startup: initialize pools, connections
yield
# Shutdown: cleanup
app = FastAPI(lifespan=lifespan)
@app.get("/health")
async def health(): return {"status": "ok"}
use axum::{routing::get, Router, Json};
use std::sync::Arc;
#[derive(Clone)]
struct AppState { /* db pools, config */ }
async fn health() -> Json<serde_json::Value> {
Json(serde_json::json!({"status": "ok"}))
}
#[tokio::main]
async fn main() {
let app = Router::new()
.route("/health", get(health))
.with_state(Arc::new(AppState {}));
let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, app).await.unwrap();
}
Consult these references based on task requirements:
| Task | Reference File |
|---|---|
| FastAPI patterns, async DB, testing | references/fastapi.md |
| Rust/Axum services, SQLx, error handling | references/rust.md |
| ML inference, quantization, vLLM | references/ml-serving.md |
| Kafka, RabbitMQ, Redis, event patterns | references/event-driven.md |
| Docker multi-stage builds, security | references/docker.md |
| Kubernetes production patterns | references/kubernetes.md |
| AWS ECS, EKS, Lambda, CDK | references/aws.md |
New Backend Service Request
│
▼
┌──────────────────────────┐
│ Latency requirement? │
│ < 10ms → Rust │
│ > 10ms → FastAPI ok │
└──────────────────────────┘
│
▼
┌──────────────────────────┐
│ ML model serving? │
│ LLM → vLLM │
│ Vision/NLP → ONNX/TensorRT│
│ None → skip │
└──────────────────────────┘
│
▼
┌──────────────────────────┐
│ Event-driven? │
│ High throughput → Kafka │
│ Complex routing → RabbitMQ│
│ Real-time → Redis Streams│
└──────────────────────────┘
│
▼
┌──────────────────────────┐
│ Deployment target? │
│ Simple → ECS Fargate │
│ Complex/Multi-cloud → EKS│
│ Event handlers → Lambda │
└──────────────────────────┘
Before deploying any service: