The method

Four layers. One compiled spine.

Each layer stacks on the one below. Foundation holds the cloud and identity. Delivery ships code. Orchestration brings every vendor into the same mesh. Intelligence watches and summarises.

Layer 1

Foundation

The ground the company stands on. Cloud, identity, secrets, source control, DNS.

  • Azure (Terraform azurerm)
  • Google Workspace (googleworkspace provider)
  • Azure Key Vault — central secret store
  • GitHub — Terraform github provider, repos + branch protection as code
  • Cloudflare — DNS as code

Layer 2

Delivery

How code ships. CI/CD, release automation, mobile pipelines, failure notifications.

  • GitHub Actions — pipelines per repo
  • Fastlane + TestFlight — mobile CI/CD
  • Discord CI/CD failure webhooks
  • Azure Container Apps — runtime

Layer 3

Orchestration

Every external tool brought into code. Vendor APIs, work management, calendars, payments.

  • Plane (CLI wrapper)
  • Monday.com (two-way GitHub sync)
  • Cal.com (CLI wrapper)
  • Stripe (setup + webhooks)
  • Discord (webhooks + bots)

Layer 4

Intelligence

Observability, analytics, AI insights, scheduled digests, cost visibility.

  • Sentry — error tracking + config-as-code
  • PostHog — shared project with super-properties
  • Claude — insight layer + agentic investigators
  • Scheduled digests to Discord

Where AI lives

Predictable first. AI where code cannot reach.

Build time

AI reads the spec and emits Terraform, GitHub Actions, runbooks, KPI queries, vendor integration modules. The output is static code committed to the customer's repo.

Refactor time

When the spec changes (new vendor, new product line, new compliance requirement), AI recompiles affected modules and opens a PR. A human reviews and merges.

Upgrade time

When upstream tools change (Terraform provider bump, new Claude model, deprecated API), AI regenerates the glue. Same review gate.

Runtime, in fixed roles

Scheduled KPI digest, cron agent, insight job, code review pass, developer machine bootstrap, alert spike summariser. Fixed inputs and outputs, no improvisation on the hot path.

Runtime, agentic investigation

Triggered by the unpredictable (customer complaint, infra spike, unexplained metric). Agents read across database, logs, source, deploys, correlate, propose a solution, open a PR.

AI is the connective tissue. Code is the spine. Agents are the response to the unpredictable. The customer can unplug us tomorrow and the compiled output keeps running. The agents become useful precisely because the platform underneath them is cohesive.

Deep dive on the agentic layer →

Engage

Every layer is portable. Every output is yours.

OneOps leaves no proprietary runtime dependency. Every Terraform file, every Action, every prompt, every SQL view lives in your GitHub org. If we disappear, the compiled code keeps running.