Asset Governance Platform
One multi-tenant platform to govern assets and regulated operations across many organizations — from a township to a hospital or defense manufacturer.
Organizations that manage assets and regulated operations across many teams need one governed system, not a pile of spreadsheets or single-tenant silos. AGP is that platform: independent organizations register assets, run them through an enforced lifecycle, schedule inspections, route approvals, and control exactly who can do what — each tenant fully isolated, everything on per-organization dashboards with a complete, immutable audit trail. The same build serves a company at the Standard bar and a government site, hospital or defense manufacturer at an elevated one — the difference is configuration, not code — and it refuses to boot a production deployment that isn't configured safely.
0
assets under governance
0
inspections due
0
approvals pending
0
tenants isolated
Gov
hardening profile active
append-only
immutable audit log
$ agp serve --profile Government
✔ config doctor: KMS key ✓ · OIDC ✓ · CORS allowlist ✓ (else: refuses to boot)
✔ Keycloak realm loaded · roles → permissions
✗ POST /api/assets (role: Inspector, org: Acme)
denied: missing asset:delete ← deny-by-default
✔ query scoped to caller's org · cross-tenant blocked
✔ audit: append-only entry sealed
Representative output — not a live instance.
●Register physical or logical assets with RFID/barcode auto-assignment, type classification, and placement in location trees and component hierarchies.
●Enforced six-state lifecycle — Draft → Registered → In-Service → Under-Inspection → Retired → Disposed. Invalid transitions are rejected at the domain layer, no matter who calls.
●Bulk operations, soft-delete & saved searches — multi-asset transition/delete with per-item results, a recycle bin with retention, and per-user named filters.
●Scheduled & recurring inspections with automatic task generation, pass/fail outcomes, and an overdue-work dashboard.
●Evidence capture — photos and PDFs attached as validated files (magic-byte checked, size-capped, path-traversal stripped).
●Multi-channel notifications — in-app, email and SMS through swappable providers; a channel failure is logged and never breaks the originating request.
●Configurable approval chains for asset transitions, budget changes and subcontract awards.
●Separation-of-duties, enforced — a requester can't approve their own request; the domain invariants make the violation impossible, not just discouraged.
●Full decision history surfaced in the audit trail, with pending-approval dashboards per user.
●Deny-by-default RBAC — every use case is gated by an explicit permission; an unknown role grants nothing.
●IdP-driven permissions — roles come from Keycloak / Entra ID; role→permission mappings are editable per organization without re-issuing tokens.
●Architectural tenant isolation — every entity carries an organization ID and queries filter by the caller's org; cross-tenant access is impossible by construction, and an architecture test proves it.
●Per-tenant dashboards & trends — each organization sees only its own assets, pending work and metrics, with day-by-day history (not just "now") and PDF/CSV export.
●Immutable audit log — every state change writes an append-only entry (actor, action, entity, time, org). Full accountability for who changed what, when.
●Deployment security profiles — Standard / Government / Healthcare progressively raise the bar (mandatory KMS keys, longer audit retention, automatic logoff); a config doctor refuses to start Production if the chosen profile's requirements aren't met.
●Regulated-industry control surface — technical safeguards mapped control-by-control to government (NIST 800-53), healthcare (HIPAA §164.312) and defense-manufacturing (ITAR, AS9100/AS9102, DFARS / NIST 800-171 / CMMC) baselines — including a hard block on awarding ITAR-controlled work to an unregistered manufacturer, and first-article records that require a human sign-off.
●Tamper resistance — optimistic-concurrency tokens prevent silent overwrites; AES-256-GCM authenticated encryption makes altered fields detectable.
●CRM, orders & finance — customers, an order lifecycle, PDF invoices, an accounts-receivable aging report, and dormant-account outreach suggestions. All money is exact decimal, never floating point.
●Subcontractor management — award and track subcontracts on an on-track / due-soon / overdue cockpit, with a transparent, rules-based risk score that flags work likely to slip before it does.
●Scoped self-service portal — a read-only token lets a customer or subcontractor see only their own records (cross-subject access returns 403), including uploading their own compliance certificates.
●Machine-to-machine integration API — an external system of record (e.g. the Ironclad mainframe) upserts assets idempotently and receives HMAC-signed webhook events.
●Ten languages — English (LTR) and Arabic (RTL) plus eight more, mirrored correctly via logical CSS, on every screen.
●Accessibility built in — full keyboard navigation, a translated 60-second guided tour, and a WCAG 2.1 AA self-assessment with zero automated-scan violations across audited screens.
●Installable PWA — app shell cached; tenant data is never cached offline (a governance system must always show live, authorized data).
●Clean Architecture, dependencies inward — a framework-free Domain layer holds the aggregates and invariants; an architecture test fails the build if the dependency rule is broken.
●CQRS application layer — every operation is a command or query, wrapped by cross-cutting authorization and validation that run before any business logic.
●Swappable infrastructure — the same code runs on an in-memory store for demo and PostgreSQL / SQL Server for production; encryption, audit, notifications and storage are all ports with pluggable adapters.
●Hardened API + React/TS SPA — HTTPS/HSTS, rate limiting, strict CSP, body-size caps, RFC 7807 errors; a React Query + OAuth2/PKCE front end across two dozen feature modules.
●Real auth, verified in CI — the test suite boots an actual Keycloak container, issues a signed JWT, and proves the API validates it, expands roles to permissions, and rejects tampered tokens. The same realm file ships for production.
●Encryption everywhere — TLS in transit; AES-256-GCM field encryption at rest with a fresh nonce per value and keys held in KMS / Key Vault, never in config.
●Supply-chain discipline — warnings are build errors, NuGet audit runs at build, and CodeQL scans C# and TypeScript on every change plus weekly.
●Threat-modelled & scanned — STRIDE threat models per subsystem, a pentest self-assessment on file, and an OWASP ZAP baseline returning zero high / medium / low alerts.
0
automated tests
0
build warnings (enforced)
0
OWASP ZAP findings
0+
domain modules
0
languages · EN + AR RTL
CI-gated
real Keycloak OIDC test
ℹ
Readiness, not certification — stated plainly. The Standard / Government / Healthcare profiles ship the technical safeguards that map, control by control, to baselines like NIST 800-53, HIPAA §164.312 and DFARS / CMMC. They make an audit straightforward — they are not a certification, and the platform can't self-certify. Operating in a real government, hospital or defense environment still requires an independent outside audit / authorization (a government ATO through an independent assessor, a HIPAA assessment, a C3PAO for CMMC) plus organizational work no software can do (SSP, POA&M, BAAs, policies, training). What the platform guarantees mechanically: its config doctor refuses to boot an insecure production deployment, and it hard-enforces the gates it can. Built to be audited — not to fake it.
.NET 9 · C#Clean Architecture · CQRS / MediatREF Core · PostgreSQL / SQL ServerFluentValidationSerilog · OpenTelemetry · PrometheusReact 18 · TypeScript 5Vite · React Query · react-i18nextKeycloak / Entra ID (OIDC)AES-256-GCMTerraform · Kubernetes · DockerGitHub Actions · CodeQL
🔒
Architecture, security posture and verified results shown in full. The source, business logic and configuration are private — this is an in-depth capability showcase, not a distribution.
Running regulated ops
across many teams?
I build multi-tenant platforms that keep complex, regulated operations organized, access-controlled and provably auditable — and that are honest about where the software stops and an outside auditor begins. Tell me what you need to govern.
Start a project →