suggestibility.ai
Sample review. The document below is fictional — the organisations, people and figures in it are invented. The review itself is real output from a suggestibility.ai board, unedited.
Architecture decision

ADR-014: Move session state from signed cookies to Redis

The same ADR, reviewed by five. Compare what the larger board found.

Board
5 reviewers
Score
35 / 100
What that means
Major issues
The board found serious problems with this document.

Consensus

All reviewers agree the single-node Redis design introduces an unacceptable availability risk on the authentication hot path and lacks production-grade hardening for security, observability, and data durability. While moving sessions to Redis improves revocation capability, the current proposal would create catastrophic outage exposure and authorization stalemate without remediation.

Findings

critical

Single-node auth SPOF

The single-node ElastiCache instance on the auth hot path means any node failure or maintenance event causes a total platform outage for all authenticated users. The team must remove this SPOF before release.

Raised by Principal Software Architect

high

Missing user-to-session revocation index

Storing sessions solely by opaque session_id prevents revoking all sessions for a compromised user_id without a blocking full-keyspace SCAN, undermining the stated theft-response goal.

Raised by Principal Software Architect

high

Stale authorization from cached roles

Caching roles inside a 14-day sliding session creates a distributed stale-authorization problem: revoked permissions remain valid until the session expires or is manually deleted.

Raised by Principal Software Architect

high

Revocation hole in dual-read migration

During dual-read migration, a session deleted in Redis can still be accepted via the legacy cookie fallback, allowing revoked or stolen sessions to persist undetected.

Raised by Data and Analytics Reviewer

medium

Write amplification and missing durability

Unthrottled TTL refreshes on every request generate unnecessary write load, and the absence of persistence, encryption-at-rest, and eviction policies threatens session integrity.

Raised by Data and Analytics Reviewer

Recommendations — ranked, not scored

  1. now Deploy a Multi-AZ Redis cluster with automatic failover to eliminate the single-node outage risk on the authentication path.
  2. now Add a user_id-to-sessions secondary index and close the dual-read hole so revoked sessions are rejected even during migration.
  3. next Fetch RBAC authoritatively per request or implement active invalidation; do not rely on long-lived cached roles for access decisions.
  4. next Define throttled TTL refresh, eviction policy, persistence configuration, and encryption before the production rollout.

Coverage

  • resilience — gap. Single-node Redis on the auth hot path with no replication or failover is an acknowledged total-outage risk.
  • security — partial. Revocation is improved, but stale role caching, missing encryption, and migration fallback holes remain.
  • observability — gap. Latency, error rate, hit ratio, and eviction metrics are absent; there are no acceptance criteria or alerting rules.
  • operations — gap. Rollback procedures, capacity margins, and Redis tuning parameters like maxmemory-policy are undefined.

The board

Principal Software Architectgoogle · gemini-3.6-flash
Security and Reliability Reviewercloudflare · @cf/mistralai/mistral-small-3.1-24b-instruct
Product Delivery Leadcloudflare · @cf/openai/gpt-oss-120b
API and Integration Architectcloudflare · @cf/google/gemma-4-26b-a4b-it
Data and Analytics Reviewercloudflare · @cf/nvidia/nemotron-3-120b-a12b
Read the document that was reviewed (3,233 characters)

ADR-014: Move session state from signed cookies to Redis

Status: Proposed

Date: 2026-07-28

Deciders: Platform team

Supersedes: ADR-006 (stateless signed-cookie sessions)

Context

Our web tier is stateless today. Session data lives in a signed cookie

(HMAC-SHA256, 4KB ceiling). Two constraints have made this uncomfortable:

  • The cookie is now 3.1KB average and 3.9KB at p99. We are one feature away

from the browser limit, and every request carries it on the wire.

  • We cannot revoke a session. Logout clears the cookie client-side, but a

copied cookie stays valid until its 14-day expiry. Support has escalated

this twice after laptop-theft reports from enterprise customers.

We evaluated three options.

Options considered

Option A — Keep signed cookies, shrink the payload. Move everything except

user_id and issued_at into a per-request database lookup. Cheapest change,

but adds a DB round trip to every authenticated request (~4,000 rps peak) and

does not solve revocation.

Option B — Redis-backed sessions. Cookie carries only an opaque session id.

Session body lives in Redis with a 14-day TTL. Revocation is a DEL. Adds an

external dependency to the auth path.

Option C — Database-backed sessions. Same shape as B, but Postgres instead

of Redis. Reuses infrastructure we already operate and back up. Higher latency

(~6ms vs ~0.4ms measured on a spike) and adds write load to the primary.

Decision

Adopt Option B. A single ElastiCache Redis node in us-east-1, cache.r6g.large,

with the session body serialised as JSON.

Rationale

Revocation is the requirement that actually forced this, and B is the only

option that makes it a constant-time operation. Latency matters on the auth

path and Redis is an order of magnitude faster than Postgres for this access

pattern. We already run Redis for the rate limiter, so the operational surface

is not new to the team.

Consequences

  • Auth now depends on Redis availability. If Redis is unreachable, users cannot

authenticate. We accept this.

  • Session cookie drops from ~3.1KB to 64 bytes, reducing average request size

by roughly 12%.

  • Estimated cost: $190/month for the node. We expect a 98% cache hit rate based

on the rate limiter's observed behaviour.

  • Migration is a dual-read period of 14 days (the old cookie TTL), after which

cookie-carried sessions are rejected.

Implementation notes

  • Session id: 128-bit random, base64url encoded.
  • TTL refreshed on each request (sliding expiry).
  • Session body includes user_id, org_id, roles, impersonator_id when an

admin is acting as a customer, and a csrf_token.

  • No changes to the login flow itself; only where the session body is stored.

Rollout

Week 1: dual-write, read from cookie. Week 2: dual-write, read from Redis with

cookie fallback. Week 3: Redis only. Week 5: remove cookie-session code path.

Open questions

  • Do we need a second Redis node? A single node has no failover, but adding a

replica roughly doubles cost and the team has not operated Redis replication

before.

  • Should roles live in the session at all, or be re-fetched per request so a

permission change takes effect immediately?

Run a review See pricing