All services

Backend Systems & APIs

Backend services and APIs that are easy to change, tested in CI and observable in production.

Request path: a web app sends POST /v2/orders to the API, which checks the contract and the caller's role, passes it to the Orders module of a modular monolith and writes to PostgreSQL. Billing hands work to a job queue and a background worker. Every part reports logs, metrics and traces.POST /v2/orders201 CreatedWeb appMobile appPartner systemAPIOpenAPI contractVersioned routesAuth and rolesModular monolithOrdersBillingAccountsPostgreSQLJob queueWorkerLogs, metrics and tracesDashboards and alertsRequest path: a web app sends POST /v2/orders to the API, which checks the contract and the caller's role, passes it to the Orders module of a modular monolith and writes to PostgreSQL. Billing hands work to a job queue and a background worker. Every part reports logs, metrics and traces.POST /v2/ordersWeb appMobile appPartnerAPIOpenAPI contractVersioned routesAuth and rolesModular monolithOrdersBillingAccountsPostgreSQLJob queueWorkerLogs, metrics and tracesDashboards and alerts
A backend we’d build. The highlighted line is one order being placed, from the web app to the database.

When teams bring us in

  • A new product needs a backend that will hold up in production.
  • An API has become hard to change without breaking the apps that use it.
  • Performance is slipping and nobody can say where the time goes.
  • Nothing is tested or monitored, so every release feels like a gamble.

What the work covers

API design

We describe each API in OpenAPI before we build it and version it, so the apps that depend on it keep working while it changes.

Service boundaries

We start with a modular monolith that has clear internal boundaries. A part becomes its own service only when that pays off in deployment, scaling or ownership.

Authentication and access

Sign-in, sessions or tokens, and role-based access that matches who does what in your organization.

Background jobs and queues

Work that shouldn’t hold up a request, such as imports, emails and long calculations, runs as background jobs with retries.

Performance

We profile before we optimize, then fix the queries, payloads and code paths that actually cost time.

Tests and observability

A test strategy that matches the risk, running in CI, plus logs, metrics and traces so problems show up before your users report them.

What you get at the end

  • An OpenAPI specification for every API we build or change
  • Architecture decision records that explain the important choices
  • Tested services running in CI
  • Dashboards and alerts for the services in production
  • Runbooks for routine operations and known failure modes
  • A handover to your team, so they can carry on without us

How an engagement runs

  1. Discovery

    We look at the product, the existing code if there is any, the data and the risks, then agree on scope, milestones and what success looks like. Taking over an existing backend usually starts with a short audit to find the fixes with the most impact.

  2. Build in short iterations

    We design and implement in clear milestones. Tests, CI and observability are part of the work from day one, not a phase at the end.

  3. Launch and handover

    We ship to production with monitoring, documentation and runbooks. Support afterwards can be ad-hoc work or a monthly retainer, depending on your needs.

Thiago Benkendorf, the senior software architect and engineer behind Nithron, does every engagement hands-on. On bigger projects he can coordinate other engineers, as he did with a six-person contractor team on a manufacturing platform rebuild, and he stays your single point of contact.

Technologies

  • Java with Spring, C# with .NET, TypeScript with Node.js, Go and Python
  • PostgreSQL and MongoDB
  • OpenAPI for API contracts

Questions

Can you work on our existing backend instead of starting over?

Yes. We regularly take over and improve existing systems. We begin with a short audit, fix what lowers risk first and then improve the parts that slow the team down, without a big-bang rewrite.

Do you split everything into microservices?

No. Most products can start as a modular monolith, which keeps complexity low and leaves a clean path to split out services later if they are needed.

Which language will you use?

Usually the one your team already knows and can maintain. We work in Java, C#, TypeScript, Go and Python, and we only suggest a change when there is a clear reason for it.

Will our team be able to maintain it after you leave?

That is what the handover is for. You keep the OpenAPI specification, the decision records, the runbooks and the tests in CI, and we can stay on for support if you want.