Gantry Internal Developer Platform

Production without infrastructure tickets.

Gantry gives developers self-service workflows to create services, manage environments, request infrastructure and deploy through governed Golden Paths. A Go control plane turns those requests into durable workflows, GitOps changes and running Kubernetes workloads.

Architecture · Local operations · Testing · Security

Developer workflows

• Create .NET, Java, Python/FastAPI and Go services from versioned templates with ownership, runbooks, resource limits and telemetry conventions.
• Follow application and environment lifecycles from creation through deployment, readiness, drift reconciliation, failure remediation and rollback.
• Request bounded PostgreSQL and Redis capabilities; readiness includes verified consumer connectivity.
• Inspect deployment evidence, dependencies, logs, traces, local SLOs, incidents and engineering Scorecards from one portal.

Platform architecture

The Next.js/React portal uses a typed PlatformApi contract. The Go API enforces authentication, team boundaries and policy, while PostgreSQL stores catalog metadata, sessions, audit records and retriable workflow state.

Infrastructure automation provisions local K3s workloads and managed capabilities. The CI/CD workflow generates source, restores dependencies, runs language tests, builds container images and evaluates Kubernetes admission before promoting desired state to Git. Argo CD reconciles that state; Gantry checks the observed revision, replicas and HTTP readiness before reporting success. The current pipeline runs inside the local platform, without an external hosted CI provider.

Prometheus, OpenTelemetry, Jaeger and structured Kubernetes logs provide operational signals. Missing or expired telemetry remains explicitly unavailable. Scorecards expose the evidence and remediation behind each result.

Security and governance include bcrypt password hashes, bounded sessions, Origin/CSRF checks, role/team authorization, idempotent mutations, audit records, namespace isolation and admission policies. Credentials stay in private operator storage; workload configuration uses secret references. See the security review for the tested boundaries and residual risks.

Local development

Frontend prerequisites are Node.js/npm and the locked dependencies:

npm ci
$env:NEXT_PUBLIC_GANTRY_MODE='demo'
npm run dev

Open http://localhost:3000. Demo mode uses explicit, stateful fixtures for frontend development and testing.

For an existing real-platform installation on Windows/WSL2:

Remove-Item Env:NEXT_PUBLIC_GANTRY_MODE -ErrorAction SilentlyContinue
./scripts/platform/Start-Local.ps1
npm run build
npm run start -- --hostname 127.0.0.1 --port 3000

The real platform requires the dedicated WSL2 distro, Docker Engine, K3s, PostgreSQL and the installed platform services. Follow operations for installation, private local login, configuration, storage limits and recovery. Real-platform mode is the default. A clean-machine reinstall has not been verified.

Verification

npm run format:check
npm run lint
npm run typecheck
npm test
npm run build

$env:NEXT_PUBLIC_GANTRY_MODE='demo'
npm run build
npm run e2e
npm run e2e:dev
Remove-Item Env:NEXT_PUBLIC_GANTRY_MODE

The testing guide covers real PostgreSQL integration tests, platform browser scenarios, runtime smoke checks and the four Golden Path build proofs. Fixture browser checks include desktop/mobile flows, accessibility and eight committed visual baselines. Real-platform tests authenticate against the Go API and create or modify actual local resources; run them serially within the documented capacity limits.

Known limitations

• One machine and one K3s node. Development, staging and production are logical namespaces, not independent production clusters.
• Local authentication, Git and trusted Docker builds; no public ingress, external cloud deployment or untrusted multi-tenant build isolation.
• Six-service/eight-claim local capacity. PostgreSQL and Redis are implemented; object storage, queues and inference workflows are not.
• Short telemetry retention: Prometheus is bounded to six hours/256 MB; Jaeger stores traces in memory. Five-minute SLOs do not establish long-term reliability.
• Recorded upstream dependency findings remain. Local verification does not establish high availability, disaster recovery, compliance or production security.

Repository layout

Path	Purpose
src/	Portal, domain types and API adapters
control-plane/	Go API, identity, workflows, migrations and service templates
platform/	Kubernetes, telemetry and admission configuration
scripts/platform/	Installation, operations and verification
tests/	Unit, fixture browser and real-platform suites
docs/	Architecture, operations, testing and portfolio material