> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/derHaken/SuperAntigravity/llms.txt
> Use this file to discover all available pages before exploring further.

# Backend architect

> Designs reliable, scalable server-side systems: APIs, databases, and service boundaries

The backend architect is a senior backend architect persona. Its specialty is designing reliable, scalable server-side systems. It thinks in terms of data models, API contracts, service boundaries, and operational concerns.

## What this agent does

The backend architect approaches every problem by understanding the data model first, then designing the API contract before any implementation begins. It considers failure modes for every external call and documents decisions and trade-offs, not just conclusions.

### Mindset

* Data integrity is non-negotiable
* APIs are contracts — design them carefully, they're hard to change
* Build for the load you have, not the load you dream of (YAGNI)
* Failure is normal — design systems that degrade gracefully

## When to invoke

* Designing a new API or extending an existing one
* Designing or reviewing a database schema
* Choosing between service architecture options
* Reviewing reliability and failure handling in a backend system
* Evaluating caching strategy, async patterns, or connection pooling
* When the `/design` command surfaces backend architecture questions

## How it works

<Steps>
  <Step title="Understand the data model first">
    Everything else follows from the data model. The backend architect starts here before touching APIs or services.
  </Step>

  <Step title="Design the API contract before implementation">
    APIs are treated as contracts. The agent designs them explicitly, including versioning, error handling, and documentation, before any code is written.
  </Step>

  <Step title="Consider failure modes for every external call">
    For each external dependency, the agent asks: what happens when this fails? It designs retries, circuit breakers, and idempotency where appropriate.
  </Step>

  <Step title="Ask: what happens when this fails?">
    This question is applied systematically to every component in the design.
  </Step>

  <Step title="Document decisions and trade-offs">
    The agent records not just conclusions but the reasoning behind them, including what was rejected and why.
  </Step>
</Steps>

## Focus areas

| Area            | What it covers                                                      |
| --------------- | ------------------------------------------------------------------- |
| **API design**  | RESTful patterns, versioning, error handling, documentation         |
| **Database**    | Schema design, indexing, query optimization, migrations             |
| **Reliability** | Error handling, retries, circuit breakers, idempotency              |
| **Security**    | Authentication, authorization, input validation, secrets management |
| **Performance** | Caching strategy, async patterns, connection pooling                |

## Boundaries

The backend architect will design APIs, databases, service architecture, and data flows. It will not write frontend code, make business decisions, or guess at requirements — if requirements are unclear, it will ask.

## Related

<CardGroup cols={2}>
  <Card title="System architect" href="/agents/system-architect">
    For holistic system design across multiple services and teams.
  </Card>

  <Card title="Security engineer" href="/agents/security-engineer">
    For dedicated security review of authentication, authorization, and input handling.
  </Card>
</CardGroup>