Inference Public

Software engineering on AWS

Build the service around the need.

Applications, APIs and integrations designed for change, failure and everyday use.

Transport staff checking digital information at a regional bus interchange.

Software that behaves when things go wrong

Public services are judged on the cases that go wrong: the payment that times out, the duplicate submission, the partner system that is down for an hour. Software that only handles the happy path creates work for staff and confusion for users.

We design and build applications, APIs and integrations around the tasks people need to complete, with failure handling, test evidence and diagnostics treated as part of the feature.

When to bring us in

  • A new service, API or integration needs building, and the failure cases matter.
  • An existing integration loses, duplicates or delays records and nobody can say why.
  • Releases are risky because there is no reliable evidence of what the software does.

What we take on, and what stays with your team

We take on: design and build of the agreed application or integration, its automated tests and diagnostics, and the evidence that it behaves as agreed.

Your team keeps: the service decisions, the priorities, the relationships with partner systems and their owners, and the running service after handover.

Engineering scope

User tasks and contracts

Start from what the user or member of staff must achieve. Define API contracts and integration boundaries explicitly, including what each side owns and what happens when the other side changes.

Data validation and access

Validate at the boundary, apply least-privilege access to data, and keep personal data out of logs.

Concurrency and idempotency

Design for duplicate delivery and concurrent updates: idempotency keys, conditional writes and clear ownership of each record.

Retries, timeouts and durable progress

Bounded retries with backoff, explicit timeouts, dead-letter queues and, where a process spans several steps, durable workflow state (for example AWS Step Functions) so a partial failure can resume rather than restart.

Test evidence and diagnostics

Contract tests, failure-case tests and structured logs with correlation identifiers, so a problem in production can be traced to a request and a revision.

An illustrative project

Illustrative example, not a client engagement

Starting state. A casework service receives submissions from a partner system. Occasionally a submission appears twice; occasionally one disappears after a timeout.

Agreed work. Trace the integration end to end, introduce an idempotency key and conditional writes, add a dead-letter queue with alerting, and write tests for duplicate delivery and partial failure.

Deliverables. The changed integration, its contract, automated tests for the agreed failure cases, a runbook for dead-letter handling and a dashboard for the integration’s health.

Acceptance. Agreed journeys and failure cases, including duplicate delivery and a partner timeout, are demonstrated against an identified revision, and the operating team has handled a dead-lettered message using the runbook.

What we need from you

  • A service owner who can describe the user tasks and decide on edge cases.
  • Access to the code, test environments and representative (safe) test data.
  • Contacts for the owners of systems you integrate with.

Costs, risks and trade-offs

Stronger guarantees such as exactly-once processing cost complexity; we agree which failure cases matter and design for those. Durable workflows and queues add components to operate, so we only introduce them where the failure they handle is real.

FinOps and cloud cost engineering covers how running costs are made attributable and managed.

Related

Read What should operational acceptance establish? and Verifying AI-generated code and tests.

See anonymised experience. Compare ways to work together.

A sensible first step

Bring the service or integration and the failures that worry you. We will discuss whether a defined build, a review of the failure cases or an embedded engineer is the right start.

A first conversation does not commit either side to anything, and we will not ask for access to your systems until a scope is agreed.

Discuss a service or integration