Governance Architecture & Technical Specs
Tamper-evident audit, compliance frameworks, approval workflows, delegation, retention, access control, and change management.
1. Audit Trail (Tamper-Evident Chain)
| Level | Description | Action |
|---|---|---|
| low | Standard operations | Log only |
| medium | Important operations | Log + retention |
| high | Sensitive data access | Log + retention + alert |
| critical | Security events | Log + retention + alert + immediate notification |
2. Compliance Engine (Multi-Framework)
Tenants define their own compliance framework records, tagged by type — SOX, GDPR, HIPAA, PCI-DSS, SOC2, ISO 27001, or Custom — with the framework's own requirements supplied as structured data. Aeion ships built-in control templates for the standard frameworks and gives you the record model plus a set of automated checks, so you can seed from a template or define a framework of your own.
Automated Control Checks:
Each requirement can attach one or more control checks. Built-in check types verify an audit trail exists for a resource, that a resource is encrypted at rest, and that access logs don't show a pattern of denied-access attempts — each failure produces a finding with a severity (critical/high/medium/low), a description, and a remediation suggestion.
Compliance Status Roll-Up:
Findings roll up into a per-resource compliance status — compliant, at-risk, or non-compliant — based on finding severity and count (any critical finding makes a resource non-compliant; multiple high-severity findings mark it at-risk). Reports aggregate pass/fail/warning counts for a framework over a date range, plus generated remediation recommendations for each failing requirement.
3. Approval Workflows (Automated Escalation)
Evaluates approval policies against every incoming request and drives a time-based escalation queue when nobody acts in time.
Policy Evaluation:
Each policy has a priority (lower wins), a set of match conditions (field, operator, value — equals/notEquals/contains/greaterThan/lessThan/in/notIn), an approver configuration (a specific user, a role, a group, or a dynamically computed approver), an escalation timeout in hours, and an optional unanimous-approval requirement.
Escalation Queue:
Requests are evaluated against enabled policies sorted by priority; the first policy whose conditions all match determines the approver set. If a request sits pending past its policy's escalation timeout, it's automatically marked escalated and a notification fires — no request silently expires because nobody happened to check.
Delegation Handling:
Before routing a decision to an approver, the workflow checks whether that approver has an active delegation on file. If so, the decision is redirected to the delegate automatically, so a manager on vacation doesn't become a bottleneck.
4. Delegation (Vacation Coverage)
| From | To | Trigger |
|---|---|---|
| scheduled | active | Start date reached |
| active | expired | End date reached |
| active | revoked | Manual revocation |
| scheduled | revoked | Manual revocation |
5. Retention Policies (Data Lifecycle)
Manages data retention rules with an archive-before-delete guarantee.
Policy Structure:
A retention policy names the target collection, a set of match conditions (field, operator, value) that identify eligible records, a retention period (a duration plus years/months/days unit), whether to archive before deleting, and where the archive should land.
Archive Before Delete:
When a policy runs, it first finds every record that's past its retention period. If archiving is enabled, each expired record is written to cold storage before anything is removed from the live database — the archive location is recorded against the job, and deletion only proceeds for records that archived successfully. Nothing is deleted without a successful archive first.
Tenant-Scoped Evaluation:
Policies are evaluated per tenant, so one tenant's retention rules never touch another tenant's data — each policy produces its own job with its own results.
Job Tracking:
Every run produces a job with a status (pending → processing → completed/failed), counts of records processed/archived/deleted/failed, start and completion timestamps, and a per-record action log — so you can always answer "what exactly happened to this record and when."
6. Access Control (Fine-Grained Policies)
Manages fine-grained access policies with priority evaluation.
Policy Structure:
A policy names the subjects it applies to (specific users, a role, or a group), the resource types and actions it covers (e.g. "orders" + "read"/"write"/"delete"), an optional set of match conditions, a priority, and an effect — allow or deny.
Priority-Based Evaluation:
Policies are evaluated in priority order (lowest number first). The first policy whose subjects, resource, action, and conditions all match wins and its effect (allow or deny) is applied — so a specific, high-priority deny can override a broader, lower-priority allow.
Time-Based Access:
Conditions can include a time window — a start time, end time, and specific days of the week — so a policy can, for example, restrict access to a resource outside business hours.
7. Change Management (Approval Workflows)
Manages change requests with impact analysis and approval workflows.
Change Request Lifecycle:
A change request records its type (standard/normal/emergency), a title and description, the resource it targets, the proposed before/after changes, its computed impact, and a status that moves through draft → submitted → under review → approved/rejected → implemented. Reviewers and the full approval history are tracked on the same record.
Impact Analysis:
On creation, a change request is scored for risk level (low/medium/high/critical), the systems it affects, whether it introduces breaking changes, its dependencies, an optional rollback plan, and estimated downtime and cost impact — giving reviewers a structured risk picture instead of a plain-text description to interpret.
Reviewer Assignment:
Each reviewer is assigned a role — reviewer, approver, or implementer — and their own status (pending/approved/rejected) with comments and a timestamp, so a multi-person sign-off chain is fully attributable.
Blueprint Integration:
A change request can link to an automation Blueprint for its execution, and the workflow can pull that Blueprint's execution history to show whether the approved change actually ran.
8. AI Risk Scoring Engine
Beyond the manual 5×5 risk-register matrix, governance includes an AI Risk Scoring Engine. It computes a 0–100 risk score from weighted factors and recommends an approval path — feeding the approval workflow so high-risk changes auto-escalate (more reviewers, higher sign-off tier) while low-risk ones flow through. The score and its contributing factors are attached to the approval record for an auditable rationale, not a black-box gate.