API and backend development

A backend that holds up under real traffic and real mistakes

We design the API contract, the data model and the operational side together — so clients have something stable to build against and you have something you can actually run.

  • Contract written before code
  • Integration tests on real data
  • Idempotent, retry-safe integrations
  • Logs and metrics from day one

Written scope and a fixed estimate within two business days. NDA on request.

POST /v1/orders

// idempotent — retries cannot double-charge

Idempotency-Key: 4f1c…a92e

{

"customer_id": "cus_8291",

"items": [ … ]

}

// 201 Created

{

"order_id": "ord_5510",

"status": "confirmed"

}

Architecture

Three layers, kept separate on purpose

Business rules live in one place. That is what stops a mobile app and a web dashboard from calculating the same total differently.

01

Interface

REST or GraphQL contract, versioned and documented, with examples for each client.

02

Application

Business rules in one place, so a mobile app and a web dashboard cannot diverge.

03

Data

PostgreSQL as the default, with the schema and indexes shaped around real queries.

Capabilities

What we build and maintain

API design

Resources, versioning, pagination and error shapes agreed before implementation, so clients are not reverse-engineering behaviour.

Database modelling

Schemas, indexes and migrations designed for the queries the product actually runs — including the slow ones you have not noticed yet.

Authentication and permissions

Sessions or tokens, scopes, and authorisation checks enforced on the server rather than trusted from the client.

Third-party integrations

Payments, email, storage, messaging and analytics connected with retries and idempotency so a webhook is not processed twice.

Background work

Queues and scheduled jobs for the things that must not block a request: exports, emails, sync, media processing.

Observability

Structured logs, error tracking and latency metrics, so a production problem is a dashboard rather than a guess.

Delivery

Five steps, contract first

  1. 1

    Contract first

    We write the endpoints and payloads before the implementation, so front end and back end can proceed in parallel.

  2. 2

    Schema and migrations

    Tables, relationships and indexes reviewed against the queries the product needs, not against a diagram.

  3. 3

    Build and test

    Endpoints implemented with integration tests that run against a real database, not only mocks.

  4. 4

    Harden

    Rate limits, validation, auth checks, timeouts and the observability needed to operate it.

  5. 5

    Deploy and document

    CI pipeline, environment configuration and a short runbook covering the failures that actually happen.

Reliability

The non-negotiables

  • Every endpoint validates input and returns a documented error shape
  • Database migrations are reversible and tested against a copy before deploy
  • Retries and idempotency keys on anything that moves money or sends a message
  • Secrets in a managed store, never in the repository or the client bundle
  • Rate limits and timeouts on public endpoints
  • Backups with a restore that has actually been run once

Stack

What we usually reach for

Runtime

  • Node.js
  • Python
  • Go

Data

  • PostgreSQL
  • Redis
  • S3-compatible storage

Delivery

  • Docker
  • GitHub Actions
  • AWS / GCP

Contract

  • REST
  • GraphQL
  • OpenAPI docs

Proof

Backends behind live products

A multi-tenant SaaS platform and a real-estate app — both running on backends we designed and still support.

FAQ

Backend questions, without the jargon

Can you work with our existing database?

Yes, and we start by reading it. Legacy schemas are usually workable; the question is whether the indexes and constraints support the new queries. If a migration is needed, we scope it separately rather than quietly rewriting data.

REST or GraphQL?

REST for most products: it is simpler to cache, monitor and debug. GraphQL earns its complexity when several clients need different slices of the same graph. We will not recommend it because it sounds modern.

How do you handle breaking changes?

Versioning plus a deprecation window, with old fields kept until clients migrate. Mobile apps in the wild cannot be force-updated, so the contract has to tolerate older versions.

Do you write tests?

Integration tests against a real database for the endpoints that carry the business logic, plus unit tests where logic is non-trivial. We do not claim 100% coverage, and we will show you what is covered.

Can you take over an API someone else built?

Yes. We begin with an audit of the contract, the data model, the tests and the deployment, then hand you a short list of risks ranked by what would actually hurt in production.

Request a quote

Have an API to build, extend or take over?

Send the current schema, the client list and the pain points. We will come back with an assessment and a scoped plan — including what we would not change.

No obligation. We will tell you if we are not the right team for the job.

  1. 1

    Tell us the goal, platforms and must-have features.

  2. 2

    We reply within two business days with scope, approach and a fixed estimate.

  3. 3

    Sign an NDA first if you prefer — nothing about your idea is public.