Relational backend systems
We build APIs for systems shaped by relational data, with permissions, auditing and event publishing built in from the first request — one permission model across all three. The common backend is delivered quickly, so engineering effort goes where it actually counts: the rules that make your system different.
Your system runs in your own cloud account. We can operate and maintain it for you, or hand it over to your team.
What we build
In most relational systems the majority of routes do the same handful of things. We start from a proven backend framework that already handles those patterns, then concentrate effort on the behaviour that is specific to your business.
Create, read, update, archive, search, check access, record an audit trail, publish an event, return a consistent response — most routes are variations on these. Rather than rebuild that infrastructure route by route, we describe your data model, operations, relationships and access rules to the framework and generate it. You get a working, consistent foundation early, without locking out the customisation that comes next.
Standardised does not mean inflexible. The framework handles the common lifecycle consistently while providing clear extension points for customer-specific behaviour — some included as standard configuration, some quoted as custom work (see pricing):
Access control should not depend on every developer remembering every check. Tenant isolation is derived from how your data relates, so it is applied the same way on every route rather than re-checked by hand. The same permission model then determines what a user or integration may read, change and receive:
Important operations should leave a reliable history. Because auditing is part of the framework lifecycle, it does not need to be reimplemented for every endpoint:
Events are part of the framework, not an afterthought. Your system publishes business events from day one, to topics that are permissioned resources under the same model as your API — so what a user or integration partner may see through the API is what they may see through your events. A delivery connector hands those events to your platform — your Kafka, Amazon SNS or EventBridge — from where onward access is governed by your platform and shared with partners.
Integrations can also map their own IDs onto your records — namespaced and tenant-scoped — so third-party systems stay in sync without custom plumbing.
API documentation is generated from the same definitions that run the API, so it can’t drift from the real behaviour. It is permission-aware: each consumer sees documentation for exactly the routes they are allowed to call — which makes onboarding your frontend team and your partners’ integration engineers faster and less error-prone.
Your system always defines and enforces its own permissions. Sign-in can come from your existing identity provider, and permission assignment — who holds which permission, in which part of your organisation — can be delivered with the system or driven from a system you already run. Identity and permissions are a pluggable seam, so moving between those arrangements later is configuration rather than a rewrite.
We are particularly well suited to software built around connected business data, where entities relate to one another:
Organisation
└─ Location
└─ Department
└─ Employee
└─ Timesheet
└─ InvoiceThese relationships often determine who owns a record, which tenant it belongs to, who may view or change it, which records appear in a search, and which events an integration partner may receive. Rather than reducing the system to disconnected endpoints, we design the API around those relationships.
Why us
Traditional API projects rebuild the same foundations every time — routing, validation, search, pagination, permissions, tenant checks, auditing, event publishing, documentation and error handling. We start with those already integrated. That doesn’t remove the need for careful modelling or custom engineering; it concentrates the effort where it creates value: your business logic, unusual access rules, specialised operations and integrations.
Our approach fits best when your product is built on a relational database, most routes follow repeatable business-data patterns, and you need a usable API surface quickly — but still need real customisation, consistent tenant isolation, auditing and secure event publishing for customers or partners. It suits teams who already have frontend, mobile or product capability and want the backend built and operated for them.
Deployment
A clear path from modelling your business to a running, operated system.
We identify the entities, relationships, tenants, users, operations and access rules.
We configure and generate the standard routes, validation, permissions, auditing and events supported by the framework.
We implement the custom rules, calculations, workflows, integrations and operations unique to your system.
We verify validation, permissions, data access, auditing, event publication and API documentation consistently across the system.
Your system is deployed into a dedicated AWS sub-account we set up in your own organisation, so everything we do is logged in your CloudTrail, in your account. We can continue to operate and evolve it for you, or hand it over to your team.
Pricing
Most engagements start with the Core Package: a secure, multi-tenant API designed around your data and deployed to production in your own AWS account. One fixed price covers systems of up to 15 models — with permissions, auditing and event publication included from the first request, not added later.
From AUD $40k (ex GST) covering systems up to 15 models, including the perpetual licence and first year of support. Renews at $6k/yr. Larger systems are quoted after discovery.
We deliver the API; screens and portals are built by your team, or quoted separately. All items subject to the technical scope described in the client guide.
The Core Package is a foundation, not a ceiling. These are quoted individually, before work begins:
Standardised does not mean inflexible. Everything below is included as standard, specified during discovery and fixed at sign-off. Changes after sign-off are quoted as change requests.
* Reviewed during discovery — this choice affects system performance and is agreed jointly.
A 45–60 minute conversation about your system, with an indicative range.
A paid discovery engagement — from AUD $7,500 for a standard system of up to 15 models — where we model your domain together. You keep the model and specification either way, and receive a firm quote for the build.
The Core Package price, fixed at discovery.
Your system is delivered under a perpetual software licence — it is yours to keep. The first year of support is included; after that, support renews at $6k/yr and covers security patches, upgrades, fault fixes and framework improvements. If support lapses the system keeps running — your licence is yours — but patches and upgrades stop. Details are in the client guide.
Your system runs in your own AWS account, billed by AWS directly to you, at cost. This is the entry configuration — the minimum a production deployment runs on. Every component scales independently; nothing is re-architected.
| Component | Entry spec | ~Monthly |
|---|---|---|
| Load balancer | 1 ALB | $17–25 |
| Application server | 1 small instance (auto-scaling) | $12–15 |
| PostgreSQL database | Small, single-AZ, 20 GB | $15–30 |
| User sign-in (Cognito) | Standard | $0–15 |
| Logs, metrics, DNS, storage | — | $5–15 |
| Production total | ~$50–100/mo | |
| Development environment | Smaller instances | +$25–40/mo |
| Both environments, typical | ~$100–180/mo |
During discovery we size the initial deployment to your expected load; scaling up is a configuration change, not a re-architecture. Once the system is business-critical we recommend a Multi-AZ database for zone-failure resilience. Figures indicative, reviewed quarterly, billed by AWS directly to your account.
About
We are a specialist backend practice for relational systems. Our work is deliberately narrow: secure, multi-tenant APIs with permissions, auditing and event publishing on one permission model, designed around the relationships in your data.
You own what we build. Your system is delivered under a software licence that is yours to keep, runs in your own AWS account, and continues to run whether or not you keep a support subscription — with clear handover terms if you ever take it fully in-house. We take on a small number of engagements and stay with them: modelling the domain, delivering the common surface quickly, engineering the parts that are genuinely yours, and operating the result.
Contact
Whether you need a new API, want to modernise an existing relational application, or need secure event publishing for integration partners, tell us about the problem.
It helps to know whether the system already has a relational database, roughly how many entities are involved, whether it is multi-tenant, who needs access, and which parts require custom business logic.