>_ services/04

Backend & API Development

Secure APIs, authentication, fast databases and background jobs that scale.

>_ live demo

api · productiondemo data
Animated API monitor: a live request log with status codes and response times, 95th percentile latency, error rate and a background job queue being processed.

The backend is where most slowdowns, outages and security holes begin. We design new backends and repair existing ones: secure sign-in with roles and permissions, documented APIs, databases that stay fast as data grows, and background jobs that run on time, every time.

We favour boring, proven technology used well — Go, Python or Rust with PostgreSQL and Redis — and a modular design where each part of the system owns its data and talks to the others through small contracts and events. That keeps the code easy to change, and lets any module move to its own service later without a rewrite.

Every change is measured. Monitoring goes in first, so improvements show up as numbers — response time, error rate, uptime — not opinions.

01 → the problem

Slow queries, fragile logins, permission checks done only in the interface and APIs nobody is watching quietly cost you users, data and revenue.

02 → what we build

  • 01REST and GraphQL APIs with OpenAPI documentation
  • 02Authentication: email, phone OTP, social login, SSO (OAuth 2.0 / OIDC) and two-factor
  • 03Fine-grained roles and permissions, including per-record ownership rules
  • 04Multi-tenant backends with database-level data isolation
  • 05Background jobs, queues, scheduled tasks and reliable event delivery
  • 06Database design, query tuning and safe zero-downtime migrations
  • 07Performance and security audits of existing systems

Secure, fast and built to last

What we do on every project of this kind — not extras you pay for later.

03 → security

  • Every route declares the permission it needs; checks run on the server for every request
  • Passwords hashed with Argon2id; account lockout, rate limits and login throttling
  • Short-lived access tokens, rotating refresh tokens and instant session revocation
  • Row-level security in PostgreSQL so one tenant can never read another's data
  • Strict input validation with clear 422 errors; parameterised queries only
  • Audit log with before and after values for every sensitive change
  • Sensitive codes (OTPs, tokens) stored hashed and purged on schedule

04 → performance

  • Indexes designed from real query patterns; slow-query log reviewed weekly
  • Connection pooling and read replicas for heavy read traffic
  • Redis caching with explicit invalidation, not guesswork
  • Transactional outbox: side effects (SMS, email, webhooks) never slow down or fail a request
  • Jobs safe to run on many servers at once (advisory locks, idempotent handlers)
  • Pagination and streaming for large lists and exports

05 → what you get

  • An audit report with prioritised fixes (for existing systems)
  • OpenAPI specification checked against the code on every build
  • Automated unit and end-to-end tests against a real database
  • Recorded, reversible database migrations
  • Dashboards and alerts for latency, error rate and job health
  • Developer documentation: architecture, modules and how to add a new one

06 → timeline

An audit takes about 1–2 weeks. A new backend or a major rework takes 4–10 weeks, delivered module by module.

07 → tech we use

  • Go
  • Python
  • Rust
  • PostgreSQL
  • Redis
  • OAuth 2.0 / OIDC
  • OpenAPI
  • Prometheus
  • Grafana

08 → common questions

Backend & API Development

Our app is slow. Where do you start?

With measurement. We add monitoring, find the slowest endpoints and queries, and fix the biggest wins first — usually missing indexes, N+1 queries, missing caching or work that belongs in a background job. You see the before and after numbers.

Which language do you recommend for a backend?

Go for most APIs: fast, simple and cheap to run. Python when data work or AI is central. Rust for performance-critical services. All with PostgreSQL. We explain the trade-offs for your team, including hiring.

How do you handle authentication and permissions?

Strong password hashing, optional two-factor login, short-lived tokens with rotation, and permissions declared per route and checked on the server. Data-level rules — such as a merchant seeing only their own orders — live in the service layer and are covered by tests.

What is a multi-tenant backend, and how is data kept separate?

One system serves many organisations, each seeing only its own data. We enforce this in the database itself with PostgreSQL row-level security, so even a mistake in application code cannot leak one tenant's data to another.

Microservices or a monolith?

Usually a modular monolith first: one deployable application split into independent modules with their own tables, talking through contracts and events. It is simpler to run, and any module can become its own service later when there is a real reason.

Can you document and test our existing API?

Yes. We write an OpenAPI specification, add end-to-end tests for the critical flows and set up a check that fails the build when the code and the documentation disagree.

How do you make sure SMS or emails are never lost?

With a transactional outbox: the message is saved in the same database transaction as the business change, then sent by a worker that retries with backoff. If the SMS gateway is down, nothing is lost and the user's request still succeeds.

Do you offer API monitoring and support?

Yes. We set up uptime and latency monitoring with alerts, and offer monthly plans for fixes, upgrades and performance reviews with an agreed response time.

Need help with Backend & API Development?

Tell us about your project and we'll send a quote made for it.

Get a quote for this