Set Up Role‑Based Access with Prompt Logging and Redaction: An Audit‑Ready 30‑Day Rollout

```typescript
// ai-trust-layer.ts
// Owners: CISO, Head of Data; Regions: us-east-1, eu-west-1; SLOs: p95_proxy_latency_ms <= 900, logging_completeness >= 99.9%
import express from 'express';
import { verify } from 'jsonwebtoken';
import crypto from 'crypto';
import { detectPII, redact } from './pii'; // hybrid rules + ML detector
import { queryLLM } from './providers'; // Azure OpenAI, Bedrock, Vertex
import { insertLog } from './auditLog'; // append-only table in Snowflake/BigQuery

const policy = {
  owners: ['ciso@company.com','headofdata@company.com'],
  regions: ['us-east-1','eu-west-1'],
  dataResidency: { EU: 'eu-west-1', US: 'us-east-1' },
  slo: { p95LatencyMs: 900, loggingCompleteness: '99.9%' },
  roles: {
    'support.agent': { scopes: ['knowledge.read','rag.query'], maxClass: 'Internal', approval: 'auto' },
    'finance.analyst': { scopes: ['knowledge.read','rag.query','worksheet.generate'], maxClass: 'Confidential', approval: 'manager+sox' },
    'legal.counsel': { scopes: ['knowledge.read','rag.query','contract.summarize'], maxClass: 'Restricted', approval: 'auto' },
    'ai.admin': { scopes: ['*'], maxClass: 'Restricted', approval: 'ciso+breakglass', expiresHours: 1 }
  },
  redaction: { patterns: ['EMAIL','PHONE','SSN','CREDIT_CARD'], confidence: 0.85, allowlist: ['sandbox:*'] },
  approvals: { 'manager+sox': ['manager','it-controls'], 'ciso+breakglass': ['ciso','sec-ops'] },
  vendors: { trainingAllowed: false } // never train on client data
} as const;

function roleFromToken(token: string) {
  const claims = verify(token, process.env.OKTA_JWKS!);
  // @ts-ignore example extraction
  return { userId: claims.sub, email: claims.email, role: claims.groups?.find((g: string)=>g.startsWith('ai.')), region: claims.region };
}

function assertAccess(role: string, scope: string, dataClass: string) {
  const r = (policy.roles as any)[role];
  if (!r) throw new Error('role_not_permitted');
  if (!(r.scopes.includes(scope) || r.scopes.includes('*'))) throw new Error('scope_denied');
  const order = ['Public','Internal','Confidential','Restricted'];
  if (order.indexOf(dataClass) > order.indexOf(r.maxClass)) throw new Error('classification_exceeds_role');
}

function residencyRegion(userRegion: string) {
  return userRegion === 'EU' ? policy.dataResidency.EU : policy.dataResidency.US;
}

function eventId(prev?: string) {
  const base = crypto.randomBytes(16).toString('hex');
  return prev ? crypto.createHash('sha256').update(prev + base).digest('hex') : base;
}

const app = express();
app.use(express.json({ limit: '1mb' }));

app.post('/llm', async (req, res) => {
  const started = Date.now();
  try {
    const token = (req.headers.authorization || '').replace('Bearer ','');
    const actor = roleFromToken(token);

    const { scope, dataClass, prompt, model, purpose } = req.body;
    assertAccess(actor.role, scope, dataClass);

    const region = residencyRegion(actor.region);
    const piiHits = await detectPII(prompt);
    const redactionApplied = piiHits.score >= policy.redaction.confidence;
    const promptRedacted = redactionApplied ? redact(prompt, piiHits.entities) : prompt;

    const vendorOpts = { model, region, trainingAllowed: policy.vendors.trainingAllowed };
    const llmResp = await queryLLM(promptRedacted, vendorOpts);

    const responsePII = await detectPII(llmResp.text);
    const responseRedacted = responsePII.score >= policy.redaction.confidence ? redact(llmResp.text, responsePII.entities) : llmResp.text;

    const eid = eventId(req.headers['x-prev-event-id'] as string | undefined);

    await insertLog({
      eventId: eid,
      userId: actor.userId,
      email: actor.email,
      role: actor.role,
      scope,
      dataClass,
      purpose, // DPIA linkable purpose-of-use
      model,
      region,
      promptHash: crypto.createHash('sha256').update(prompt).digest('hex'),
      promptRedacted,
      responseHash: crypto.createHash('sha256').update(llmResp.text).digest('hex'),
      responseRedacted,
      redaction: { request: redactionApplied, response: responsePII.score >= policy.redaction.confidence, confidence: Math.min(piiHits.score, responsePII.score) },
      approvals: req.body.approvals || [],
      latencyMs: Date.now() - started,
      timestamp: new Date().toISOString()
    });

    res.setHeader('x-event-id', eid);
    res.status(200).json({ text: responseRedacted, meta: { region, latencyMs: Date.now() - started } });
  } catch (e: any) {
    res.status(403).json({ error: e.message || 'access_denied' });
  }
});

app.listen(8080, () => console.log('AI Trust Layer running on :8080'));
```

{
  "title": "Set Up Role‑Based Access with Prompt Logging and Redaction: An Audit‑Ready 30‑Day Rollout",
  "published_date": "2025-10-29",
  "author": {
    "name": "Michael Thompson",
    "role": "Head of Governance",
    "entity": "DeepSpeed AI"
  },
  "core_concept": "AI Governance and Compliance",
  "key_takeaways": [
    "Put an AI trust layer between users and all LLMs to enforce RBAC, log prompts/responses, and redact PII before it leaves your boundary.",
    "Design logs for auditors: immutable IDs, actor-role mapping, data classification, residency, redaction evidence, and purpose-of-use.",
    "Deliver in 30 days: audit → pilot → scale with a minimal surface area proxy, Okta groups, and append-only storage in Snowflake/BigQuery.",
    "Business outcome: 70% fewer audit exceptions on AI usage and 180 analyst-hours returned per quarter from automated evidence packets."
  ],
  "faq": [
    {
      "question": "Will this slow down developers or analysts?",
      "answer": "The proxy adds ~400–900 ms p95. We measure and keep it under a defined SLO. Teams gain faster approvals because evidence is automatic and access is clear."
    },
    {
      "question": "Can we deploy entirely on-prem or in a private VPC?",
      "answer": "Yes. We support on‑prem and VPC deployments across AWS, Azure, and GCP. Logs stay in your Snowflake/BigQuery with KMS encryption and RBAC."
    },
    {
      "question": "How do you prove redaction actually worked?",
      "answer": "We store pre/post redaction hashes, entity counts, confidence scores, and test fixtures. Auditors can replay samples and compare hashes while content remains masked."
    }
  ],
  "business_impact_evidence": {
    "organization_profile": "Mid‑market fintech (1,200 employees) operating in US/EU; SOC 2 Type 2; SOX in scope; Azure + Snowflake stack.",
    "before_state": "Multiple teams used direct LLM API keys; no centralized RBAC; fragmented logs; inconsistent redaction; EU data sometimes routed to US endpoints.",
    "after_state": "All LLM calls brokered via a VPC trust layer with Okta RBAC. 100% prompt/response logging with pre/post redaction and append‑only storage in Snowflake. Residency forced by code and infra. Vendor settings disable training on client data.",
    "metrics": [
      "70% reduction in AI‑related audit exceptions within one quarter.",
      "180 analyst‑hours/quarter returned by automated evidence packet and self‑serve queries.",
      "99.98% logging completeness; p95 additional latency 680 ms.",
      "Zero incidents of vendor training on client data; EU data pinned to eu‑west‑1."
    ],
    "governance": "Legal/Security/Audit approved because access is role-based via Okta, prompts/responses are logged with immutable IDs and redaction evidence, residency is enforced in code and infra, and models are configured to never train on client data; human-in-the-loop approvals exist for SOX and break-glass scopes."
  },
  "summary": "CISOs: Stand up RBAC, prompt logging, and redaction in 30 days for audit-ready AI. Evidence on demand, data residency enforced, and zero vendor key sprawl."
}