# The full back-end review checklist

Verified 2026-09 against <https://cheatsheetseries.owasp.org/>,
<https://www.rfc-editor.org/rfc/rfc9457.html> and <https://owasp.org/API-Security/editions/2023/en/0x11-t10/>.

Work the areas in the order the skill body lists them. Report only what you find; a section with
nothing in it needs no line in the output.

## 1. Correctness

- **Edge cases**: empty collection, `null`, zero, negative, maximum value, duplicate input, Unicode
  (including combining characters and emoji in length checks), very large payloads.
- **Concurrency**
  - Check-then-act across requests (`if not exists then insert`) → unique constraint,
    `INSERT … ON CONFLICT`, or a lock. Two requests will interleave; the test suite will not show it.
  - Read-modify-write → optimistic concurrency with a version column, or `SELECT … FOR UPDATE`.
  - Shared mutable state in a singleton, static field or module-level object is a race by default.
- **Time**: stored and compared in UTC, converted at the edge; an injectable clock rather than
  `DateTime.UtcNow`/`Date.now()` so it is testable; date arithmetic through a date library, never
  `+ 86_400`, which is wrong across a DST boundary.
- **Money**: a decimal type or integer minor units, always with a currency; an explicit rounding mode;
  never a float or double. `0.1 + 0.2` is a production incident in a billing system.
- **Error handling**: specific exception types, no empty catch, no swallowed failure that returns
  success. A `catch` that logs and continues needs a comment explaining why continuing is correct.

## 2. Transactions and idempotency

- The transaction boundary wraps the whole invariant — not each statement, and not the whole request.
- **No HTTP call, queue publish or file write inside a database transaction.** It holds locks for the
  duration of a network call you do not control.
- A state change plus a published event needs a **transactional outbox**, not two independent writes
  (`messaging-patterns`).
- Every consumer, webhook receiver, retried job and retryable POST tolerates a duplicate: a dedupe
  key, an upsert, or an idempotency-key table.
- Acknowledge **after** the effect commits, not before.

## 3. Security

- **Injection**: parameterised queries only. No string-built SQL, shell command, LDAP filter, path or
  template expression containing user input. An allow-list beats an escape function.
- **Authorization on every path**: each new endpoint, handler, GraphQL resolver, admin route and
  message handler declares its policy. Object-level checks prevent IDOR — scope every lookup by the
  caller's tenant or ownership, and return `404` rather than `403` so existence does not leak.
- **Mass assignment**: reject unknown fields on DTOs that can set roles, prices, statuses or ids.
- **SSRF**: a user-supplied URL fetched server-side needs a scheme and host allow-list, and must block
  private and link-local ranges **after** DNS resolution — checking the hostname before resolving is
  bypassed by a record pointing at `169.254.169.254`.
- **Deserialization**: no polymorphic or type-carrying deserialization of untrusted data
  (`BinaryFormatter`, Java native serialization, `pickle`, YAML `load`).
- **Secrets**: from a secret store or the environment, never in code, config files, fixtures or logs.
  A secret in a migration or a test fixture is still a leaked secret and needs rotation, not deletion.
- **Crypto**: vetted libraries only; passwords with Argon2, bcrypt or scrypt; constant-time comparison
  for signatures and tokens.
- **Output**: no personal data, token or stack trace in a log or in a response to a client.

## 4. Personal data

- A new column or event field holding personal data: is it needed, and is it in the data inventory?
- Is there a deletion path? A "delete my account" request must reach this new table, this cache, this
  event log and this backup policy — a field added today with no deletion path is a compliance debt
  nobody will find later.
- Retention: does anything expire this row, or does it live forever by default?
- Logs and analytics: personal data must not be in them, including in a URL path that gets logged.

## 5. Data and migrations

- **Expand / contract**, always: add a nullable column or new table → deploy code that writes both →
  backfill → switch reads → drop the old one in a **later** release. Never rename or drop in the same
  deploy that stops using it — the previous version is still running during a rolling deploy.
- Large tables: no blocking `ALTER`; `CREATE INDEX CONCURRENTLY` on Postgres, online DDL elsewhere;
  backfills in throttled batches; an explicit lock timeout so a migration fails fast instead of
  queueing every write behind it.
- New query patterns have supporting indexes; new foreign keys are indexed; unique constraints
  actually enforce the business rule the code assumes.
- Migrations are forward-only and re-runnable, or have a tested down path. Details:
  `database-migrations`.

## 6. API and message contracts

- Breaking without a version: removing or renaming a field, changing a type or format, making an
  optional field required, tightening validation, changing a status code, a default, or pagination
  semantics.
- Errors use the service's standard shape (RFC 9457 problem+json here), with no internals leaked.
- List endpoints paginate with a server-enforced maximum page size.
- Event and message schemas evolve additively; consumers ignore unknown fields. Full rules:
  `api-design`, `messaging-patterns`.

## 7. Resilience

- A **timeout** on every outbound call — connect and total. Many client libraries default to
  infinite, which turns one slow dependency into your outage.
- Retries only for idempotent operations, with exponential backoff **and jitter**, capped, and not
  stacked at several layers (a client retrying three times inside a handler retrying three times is
  nine calls to a service that is already struggling).
- A circuit breaker or bulkhead around a dependency that fails often on a hot path; graceful
  degradation where a non-critical dependency is down.
- Queue consumers: bounded concurrency, a dead-letter path, and a visibility timeout or lock duration
  longer than the slowest handler — otherwise the message is redelivered while it is still being
  processed.

## 8. Performance

- **N+1**: a query inside a loop, a lazy-loaded relation touched during serialisation, or a GraphQL
  resolver without a data loader.
- Unbounded queries: no `LIMIT`, a whole table loaded into memory, an export with no streaming.
- Blocking I/O on an async path: `.Result`/`.Wait()` in .NET, `*Sync` calls in Node.
- Caches: does the key include the tenant or user where it should? Is there a TTL and an invalidation
  path? Is there stampede protection on a hot key?
- Allocation in hot loops, a regex compiled per call, an unbounded in-memory collection.

Name the symptom and hand the depth to `dotnet-performance` or `nodejs-performance`.

## 9. Observability

- Structured logs at the right level, one per failure rather than one per retry layer.
- A correlation or request id that flows through logs, outbound calls and published messages.
- Metrics for new behaviour: rate, errors, duration. A new dependency with no metric is invisible
  during the incident it causes.
- W3C `traceparent` propagated across HTTP and message headers (`service-operability`).

## 10. Tests

- A test that **fails without the change**. Ask for it when the change is a bug fix.
- Assertions on outcomes, not on which mocks were called.
- Integration tests against a real database or broker for queries, migrations and transactions.
- The failure paths that this change introduces: timeout, 5xx, duplicate message, concurrent update.
- Open the tests the description claims exist. An assertion-free test that passes either way is worse
  than no test, because it buys confidence it has not earned.

## 11. Dependencies and supply chain

- A new dependency: maintained, licence compatible (flag GPL and AGPL in a proprietary service), no
  known advisories, and not a duplicate of something already present.
- The lockfile is committed and the build installs from it (`npm ci`, `dotnet restore --locked-mode`).
- Audit runs in CI: `npm audit signatures` for provenance, `NuGetAudit` for .NET.
- A version bump in a lockfile-only diff still deserves a look at what changed, especially for
  anything that touches crypto, parsing or serialisation.

## 12. Operability and rollout

- Config validated at start-up; nothing environment-specific hardcoded.
- Dockerfile: non-root user, no secrets in layers, a pinned base image, exec-form `CMD` so the
  process receives `SIGTERM`.
- Health probes distinguish liveness from readiness (`service-operability`).
- Risky behaviour behind a feature flag, with a stated rollout (canary or percentage) and rollback.
- **Can the previous version run against the new schema and the new message format?** If not, the
  deploy cannot be rolled back, and that is a `[blocker]` regardless of how good the code is.

## 13. Serverless specifics

- Cold start: a heavy dependency graph or a large package in the request path.
- Concurrency limits, and a database pooler in front — each instance opens its own pool.
- The handler is idempotent: every serverless platform retries.
- No in-process background work after the response; the instance may be frozen immediately.
- No reliance on in-memory state between invocations, including caches and counters.
