Skip to content

t1k:web:core:backend-development

FieldValue
Modulecore
Version1.26.1
Effortmedium
Tools—

Keywords: API, backend, FastAPI, go, GraphQL, microservices, NestJS, node.js, python, REST

/t1k:web:core:backend-development
[framework] [task]

Production-ready backend development with modern technologies, best practices, and proven patterns.

  • Designing RESTful, GraphQL, or gRPC APIs
  • Building authentication/authorization systems
  • Optimizing database queries and schemas
  • Implementing caching and performance optimization
  • OWASP Top 10 security mitigation
  • Designing scalable microservices
  • Testing strategies (unit, integration, E2E)
  • CI/CD pipelines and deployment
  • Monitoring and debugging production systems

Languages: Node.js/TypeScript (full-stack), Python (data/ML), Go (concurrency), Rust (performance) Frameworks: NestJS, FastAPI, Django, Express, Gin Databases: PostgreSQL (ACID), MongoDB (flexible schema), Redis (caching) APIs: REST (simple), GraphQL (flexible), gRPC (performance)

See: references/backend-technologies.md for detailed comparisons

Core Technologies:

  • backend-technologies.md - Languages, frameworks, databases, message queues, ORMs
  • backend-api-design.md - REST, GraphQL, gRPC patterns and best practices

Security & Authentication:

  • backend-security.md - OWASP Top 10 2025, security best practices, input validation
  • backend-authentication.md - OAuth 2.1, JWT, RBAC, MFA, session management (internal studio services: studio-auth first, docs/studio-auth.md)

Performance & Architecture:

  • backend-performance.md - Caching, query optimization, load balancing, scaling
  • backend-architecture.md - Microservices, event-driven, CQRS, saga patterns

Quality & Operations:

  • backend-testing.md - Testing strategies, frameworks, tools, CI/CD testing
  • backend-code-quality.md - SOLID principles, design patterns, clean code
  • backend-devops.md - Docker, Kubernetes, deployment strategies, monitoring
  • backend-debugging.md - Debugging strategies, profiling, logging, production debugging
  • backend-mindset.md - Problem-solving, architectural thinking, collaboration

Managed Database — Optimize Queries By Default

Section titled “Managed Database — Optimize Queries By Default”

If the data tier is a managed cloud Postgres (Neon, Supabase, RDS) rather than a container on the same host, every query is a network round trip instead of a local call — and that one hop can dominate a request’s latency. Optimization stops being a throughput concern and becomes a per-request one.

Default to optimizing queries:

  • Count round trips, not rows. Two queries in one round trip beat one query in two. Batch reads (WHERE id = ANY($1)), use RETURNING instead of insert-then-select, and collapse read-modify-write into a single statement.
  • Never loop queries inside a request handler. Fetch the set, join, or use a CTE. An N+1 that was invisible against a local database is a user-visible stall against a remote one — 50 sequential queries at ~45 ms each is ~2.3 seconds of pure round-trip latency in a single request.
  • Chatty transactions pay per statement. BEGIN / COMMIT are round trips too; a 5-statement transaction costs ~6 hops. Push the logic into one statement where you can.
  • Use the pooled endpoint for the app (the direct one is for restores and DDL). Connection setup over TLS is several round trips — never open a connection per request.
  • Cache read-heavy paths. A cache hit avoids the round trip entirely; that cache/DB gap just widened by orders of magnitude.

Measurements, the billing model behind “chatty is also expensive”, and the correct way to measure the hop: the t1k-web-devops-core skill’s managed-postgres-economics.md reference. Code-level detail: references/backend-performance.md § “The database is REMOTE now”.

Security: Argon2id passwords, parameterized queries (98% SQL injection reduction), OAuth 2.1 + PKCE, rate limiting, security headers

Performance: Redis caching (90% DB load reduction), database indexing (30% I/O reduction), CDN (50%+ latency cut), connection pooling

Testing: 70-20-10 pyramid (unit-integration-E2E), Vitest 50% faster than Jest, contract testing for microservices, 83% migrations fail without tests

DevOps: Blue-green/canary deployments, feature flags (90% fewer failures), Kubernetes 84% adoption, Prometheus/Grafana monitoring, OpenTelemetry tracing

NeedChoose
Fast developmentNode.js + NestJS
Data/ML integrationPython + FastAPI
High concurrencyGo + Gin
Max performanceRust + Axum
ACID transactionsPostgreSQL
Flexible schemaMongoDB
CachingRedis
Internal servicesgRPC
Public APIsGraphQL/REST
Real-time eventsKafka

API: Choose style → Design schema → Validate input → Add auth → Rate limiting → Documentation → Error handling

Database: Choose DB → Design schema → Create indexes → Connection pooling → Migration strategy → Backup/restore → Test performance

Security: OWASP Top 10 → Parameterized queries → OAuth 2.1 + JWT → Security headers → Rate limiting → Input validation → Argon2id passwords

Testing: Unit 70% → Integration 20% → E2E 10% → Load tests → Migration tests → Contract tests (microservices)

Deployment: Docker → CI/CD → Blue-green/canary → Feature flags → Monitoring → Logging → Health checks