Real Problems NORDON Solves

See it in action

// What your AI sees at session start:
// "Previous session found a race condition in OrderService.checkout().
//  Mutex and optimistic locking both failed. Leading hypothesis:
//  stale cache between validateInventory() and deductInventory().
//  Suggested next step: read-through cache invalidation."

async function checkout(orderId: string) {
  // AI immediately suggests the right fix:
  const inventory = await cache.readThrough(
    `inventory:${orderId}`,
    () => db.inventory.findUnique({ where: { orderId } })
  );
  // No more stale reads between validate and deduct
}

See it in action

# New developer asks their AI: "How do I deploy?"
# AI responds with the exact procedure from team memory:

$ npm run test:ci        # Step 1: Run tests
$ npm run build:prod     # Step 2: Build
$ kubectl apply -f k8s/prod/migrations.yaml  # Step 3: Migrate FIRST
$ kubectl apply -f k8s/prod/app.yaml         # Step 4: Then deploy
$ curl https://api.example.com/health        # Step 5: Verify

# WARNING: Never deploy on Fridays (incident #247)

See it in action

// Developer B starts a new API endpoint.
// AI automatically warns about the team decision:

// "Team decision (2025-11-15): REST over GraphQL for all
//  public APIs. Benchmarks showed 3x better performance.
//  Applies to all new endpoints in /api/v2/."

// routes/notifications.ts
export const notificationRoutes = new Hono()
  .get("/api/v2/notifications", listNotifications)   // REST, consistent
  .get("/api/v2/notifications/:id", getNotification)  // with team decision
  .post("/api/v2/notifications", createNotification);

See it in action

# Developer modifies deploy.yaml
# NORDON automatically surfaces the failure memory:

# deploy.yaml
apiVersion: apps/v1
kind: Deployment
spec:
  template:
    spec:
      # AI reminds: "CRITICAL: Keep this initContainer.
      # Removing it causes 500 errors for 30-60s after deploy.
      # See failure memory from incident on 2025-10-03."
      initContainers:
        - name: run-migrations
          command: ["npm", "run", "db:migrate"]
      containers:
        - name: app
          image: myapp:latest

See it in action

// Day 3: Building frontend permission gates
// AI already knows the full context from day 1 and 2:

// "Permission model uses RBAC schema (day 1).
//  API endpoints at /api/v2/permissions (day 2).
//  Middleware pattern for route-level checks.
//  Must be backward-compatible with session tokens."

import { usePermissions } from "@/hooks/usePermissions";

function AdminPanel() {
  const { hasPermission } = usePermissions();

  // AI suggests the right pattern, matching the RBAC schema
  if (!hasPermission("admin:manage_roles")) {
    return <AccessDenied />;
  }
  return <RoleManagement />;
}

See it in action

# Knowledge Graph reveals connected memories:
#
# [Decision: REST over GraphQL] ──── [Constraint: ALB limits]
#         │                                    │
#         ├──── [Pattern: API response format]  │
#         │                                    │
#         └──── [Failure: GraphQL N+1] ────────┘
#
# Clicking any node shows full context.
# Filtering by "DECISION" highlights all architecture choices.
# Cluster view groups related memories by topic.

See it in action

// Reviewer sees polling in the PR and asks their AI:
// "Why is this using polling instead of WebSockets?"

// AI responds with the decision context:
// "Team decision: Polling over WebSockets for dashboard.
//  WebSockets caused connection storms behind ALB
//  (100-connection limit per target). Polling every 5s
//  with ETag caching = 90% fewer connections."

useEffect(() => {
  const interval = setInterval(async () => {
    const res = await fetch("/api/dashboard", {
      headers: { "If-None-Match": etag },  // ETag caching
    });
    if (res.status !== 304) {
      setData(await res.json());
      setEtag(res.headers.get("ETag"));
    }
  }, 5000);  // 5s polling — documented tradeoff
  return () => clearInterval(interval);
}, []);