Backends & APIs

Backends that hold. Under real load.

REST, GraphQL, gRPC, WebSocket, event-driven. Node.js, Python, Go based on context. Architecture that scales from MVP to 100M requests/month. Full observability, automated tests, CI/CD deployment.

Start a backend project POST See our API types

Node.js · Python · Go · TypeScript
REST · GraphQL · gRPC · WebSocket
PostgreSQL · MongoDB · Redis · Kafka
99.9% uptime · p99 latency < 100ms

The context

A backend that crashes costs more than a product that ships late.

In 2026, an app or site without a solid backend is a time bomb. At 100 beta users, everything works. At 10,000 users, latency explodes. At 100,000 users, the server crashes Monday morning. Every downtime costs conversions, trust and SEO — Google demotes sites with degraded Core Web Vitals from slow APIs.

The classic trap: start in « fast MVP » mode with Firebase Functions and some Node, then realise at scale that everything is wired badly. Typical re-architecture under pressure cost: 3-6 months of product freeze and €80-150k. Our approach: build from day one for realistic 18-month load, not theoretical ideal.

Our conviction: a solid backend stands on 4 pillars. Clear architecture (microservices or modular monolith depending on context), full observability from day 1, automated tests passing every commit, reproducible deployment without human intervention. One principle: if it must break, break cleanly and you must know before your customer.

99.9%

Guaranteed uptime

Max 8h43 cumulative downtime per year

< 100ms

p99 latency

On 99% of API requests under nominal load

100M

Requests/month

Typical load held without degradation by our backends

Silent regression

Sentry + Grafana alerting before a user notices

What we build

Six types of APIs and backends.

From MVP monolith backend to distributed event-driven architecture, we pick just-enough complexity — no more.

HTTP/JSON

Classic REST API

The universal standard.

Robust REST API with OpenAPI 3.1, clean versioning, pagination, filtering, rate-limiting, JWT or OAuth 2.1 auth. Interactive Swagger or Scalar documentation. Most common case: 70% of our projects.

GraphQL/HTTP

GraphQL

When the frontend needs flexibility.

Apollo Server or Yoga, schema-first with type codegen frontend-side. N+1 solver (DataLoader), persisted queries for prod, WebSocket subscriptions for real-time. Ideal for complex apps with multiple consumers (web + mobile).

gRPC/HTTP2

gRPC microservices

When inter-service performance matters.

Internal services in gRPC (Protobuf, HTTP/2, bidirectional streaming). 10× faster than REST for server-to-server calls. Service mesh (Linkerd or Istio) for observability and traffic management.

WebSocket

Real-time WebSocket

Chat, live dashboards, gaming.

Socket.IO, native WebSocket or Server-Sent Events depending on case. Horizontal scaling with Redis pub/sub. Auto reconnect, presence tracking, guaranteed message ordering. For apps where each second counts.

Async/Bus

Event-driven & message bus

When services must stay decoupled.

Apache Kafka, RabbitMQ or AWS SQS/SNS. CQRS architecture, event sourcing where relevant. Strong decoupling: a service can fail without breaking others. Ideal for fintech, e-commerce, IoT, multi-tenant platforms.

Batch/Stream

ETL & data pipelines

When data must move.

Transformation pipelines between systems: data lake → analytical warehouse, CRM ↔ ERP sync, external feed aggregation. Apache Airflow, Dagster, Prefect or custom Python code based on volume. Automated data quality tests.

Our approach

Four steps, from schema to deployment.

We start by modelling your business domain cleanly. A solid data schema is worth two years of avoided refactoring.

01 /step/01

Domain modeling (1-2 wks)

Workshop with your team to understand the business. Modelling entities (users, resources, events), use cases, business invariants. Architecture choice (modular monolith vs microservices) based on complexity and team.

deliverable: "ERD + architecture diagram + ADR (Architecture Decision Records)"

02 /step/02

Schema & contracts (1-2 wks)

DB schema (PostgreSQL most often), API schema (OpenAPI 3.1, GraphQL SDL or Protobuf). Contract tests with examples. Your validation before any business code line.

deliverable: "DB schema + API contract + testable mock server"

03 /step/03

Build & test (4-10 wks)

Incremental implementation, continuous deployment to staging. Unit tests on business logic, integration tests on endpoints, load tests (k6 or Artillery) to validate performance before prod.

deliverable: "API live on staging + tests > 80% coverage + load test report"

04 /step/04

Production & observability (1-2 wks)

Production deployment with progressive rollout. Sentry (errors), Grafana (metrics), Loki (logs), Tempo (traces) setup. Slack/PagerDuty alerting. Ops runbook for typical incidents. 30-day guarantee after live.

deliverable: "API in production + dashboards + runbook + 30-day guarantee"

Tech stack

The tools we actually use.

Proven stack on multi-million-request production deployments. Technical choices aligned with needs, not fashion.

Languages

Node.js (TypeScript) · Python · Go · Rust

TS for most (DX, ecosystem). Python for data/ML. Go when performance matters (high-throughput microservices). Rust for extreme cases (parsing, crypto).

API frameworks

Fastify · NestJS · FastAPI · Hono · Echo

Fastify for pure TS perf. NestJS for big projects (DI, structure). FastAPI for Python (Pydantic validation). Hono for edge (Cloudflare Workers). Echo in Go.

Databases

PostgreSQL · MongoDB · Redis · ClickHouse

PostgreSQL by default (solid relational, JSON support). MongoDB if truly document-first. Redis for cache and queue. ClickHouse for analytics.

Queues & event bus

Kafka · RabbitMQ · BullMQ · AWS SQS/SNS

BullMQ (Node + Redis) for simple jobs. RabbitMQ for complex routing. Kafka for event sourcing and massive streaming. AWS SQS when already on AWS.

Observability

Sentry · Grafana · Loki · Tempo · OpenTelemetry

Sentry for errors (essential). Grafana stack (Loki logs, Tempo traces, Prometheus metrics). OpenTelemetry for standardised instrumentation.

Deployment & infra

Docker · Kubernetes · Vercel · Railway · AWS · Cloud Run

Vercel or Railway to start fast. Kubernetes (GKE/EKS) past 3-5 services. Cloud Run for containerised serverless. AWS if ecosystem already in place.

Measurable guarantees

Four contractual commitments.

99.9%

Guaranteed uptime

On rolling 30 days. Vercel/AWS/GCP SLA always behind. Proactive maintenance included.

<100ms

p99 latency

99% of API requests respond in under 100ms under nominal load. Measured by you with Pingdom or equivalent.

80%+

Test coverage

Unit tests on business logic + integration tests on endpoints. CI pipeline blocks regressions.

Silent regression

Sentry catches 100% of errors, Slack/Pager alerting. You know before your customer that there's a problem.

Preise

Jedes Projekt ist einzigartig. Das Angebot auch.

Statt abstrakter Pakete passen wir uns deinem Kontext an: Umfang, Komplexität, Fristen, Einschränkungen. Schreib uns in 3 Sätzen, was du tun möchtest — wir kommen mit einem festen Angebot innerhalb von 48 Werkstunden zurück.

Antwort innerhalb von 48 Werkstunden Angebot anfordern →