Platform Evolution — Crossplane, Temporal & AI-Augmented DevEx

📐 The Operating Model

A platform isn't a product — it's a product organization. The job of a platform team is to make the path of least resistance also be the path of greatest compliance, observability, and reliability. Everything below is built around that principle.

🏗️ Layered IaC — Terraform for Substrate, Crossplane for Self-Service

Pure-Terraform IDPs hit a wall: developers can scaffold an app in five minutes but still file a ticket for the database that app needs. The bottleneck moves but doesn't disappear. Crossplane closes the loop — cloud resources become Kubernetes APIs, exposed through Backstage golden paths, reconciled by ArgoCD, governed by Compositions written once.

Why this layering matters

Terraform owns what changes monthly; Crossplane owns what changes daily. Compliance defaults are written once in a Composition and inherited by every subsequent Claim — not copy-pasted into every Terraform module. Platform team capacity shifts from "ticket queue for cloud resources" to "improving the catalog of resources developers can self-serve."

Worked example — XPostgreSQLInstance

A developer requests a database through Backstage. The scaffolder commits this Claim:

apiVersion: platform.example.com/v1alpha1
kind: PostgreSQLInstance
metadata:
  name: claims-service-db
  namespace: claims-service
spec:
  parameters:
    storageGB: 50
    instanceClass: db.t3.medium
    multiAZ: true
  compositionRef:
    name: postgresql-aws-standard
  writeConnectionSecretToRef:
    name: claims-service-db-connection

The Composition (authored once by the platform team) materializes:

• RDS instance in a private subnet, encrypted with KMS, automated backup with 30-day retention
• Parameter group enforcing TLS in transit and slow-query logging
• Security group scoped to the requesting namespace's pod CIDR
• Secrets Manager secret with rotation enabled
• External Secrets Operator ExternalSecret syncing credentials into the app namespace
• Calico NetworkPolicy egress allowing the app namespace to reach the RDS endpoint
• Cost allocation tags: Owner, App, Environment, CostCenter

The developer never sees AWS console, never writes Terraform, never files a ticket. The platform team writes the Composition once and every future PostgreSQL request inherits the controls.

⏱️ Temporal — Durable Workflows for Stateful Domains

Insurance, financial services, and any regulated domain runs on long-lived stateful processes — underwriting decisions, claims adjudication, settlement reconciliation, policy lifecycle events. These workflows span hours, days, or weeks; they retry; they involve human-in-the-loop steps; they need full audit trails. REST endpoints and cron jobs aren't the right primitive. Temporal is.

The architectural narrative for regulated workloads

This is the layer most platform teams under-invest in — and it's the layer that matters most for insurance, banking, and any domain where business processes don't fit in a request-response cycle. Building it as part of the platform from day one prevents the inevitable proliferation of bespoke BPM tools, hand-rolled state machines, and brittle cron-job orchestration.

🤖 AI-Augmented Developer Experience

AI tooling is the largest single lever on engineering productivity available right now. The platform team's job isn't to choose whether developers use AI — it's to make sure they use it safely, consistently, and measurably. That means provisioning the tools, integrating them into the golden paths, and instrumenting the outcomes.

Tooling strategy

The two tools complement each other

Platform team responsibilities

• Procurement & provisioning — enterprise licensing, SSO, content exclusion, prompt logging policies, data residency review
• Golden paths — every Backstage template ships with Copilot/Claude Code configuration, custom instructions, and example prompts for the language and framework
• Guardrails — policy on which repos, which data sources, which production systems agents are allowed to touch; secrets scanning on every commit regardless of source
• Measurement — accept/reject rates, time-saved estimates, developer survey signal, downstream code quality metrics; integrate AI tooling adoption into platform health dashboards
• Education — internal demos, prompt libraries, "AI office hours" embedded with stream-aligned teams; treat fluency as a platform deliverable, not an individual concern

The honest framing

📊 Developer Productivity Metrics — DORA + SPACE

A platform's success isn't measured by how cleverly it's architected. It's measured by whether engineers ship faster, more safely, and more happily because of it. DORA gives the delivery view; SPACE adds the human view; together they tell the truth.

The DORA four — operational delivery health

The SPACE five — developer experience health

What good looks like — directional targets

🛡️ Compliance & Security by Construction

Regulated industries can't choose between speed and control. The platform is how you get both — by encoding controls in the substrate so the fast path is also the compliant path.

The SOX / regulatory framing

Compliance teams ask three questions: Who can change production? How is change reviewed? Where's the evidence? The answer in this operating model is the same for every question: Git. Production changes are pull requests. Reviews are PR approvals from CODEOWNERS-defined groups. Evidence is the immutable Git history plus ArgoCD reconciliation logs plus Temporal workflow histories. Auditors learn to read PRs instead of ticket queues — and the audit gets faster every quarter as the platform matures.

🚀 Migration Path — How to Get There from Where You Are

No team gets to greenfield this. The realistic path is incremental: capture quick wins, build the substrate in parallel, migrate workload-by-workload as teams pull rather than push.

Phase 1 · Foundation (months 1–3)

• Backstage portal stood up with catalog covering all existing services (importer scripts from Git, Jira, ServiceNow as needed)
• First golden path: highest-volume service archetype — typically a stateless web service in the dominant language
• Terraform substrate: VPC, EKS, ArgoCD, Calico, ESO, Karpenter, observability collectors
• GitHub Copilot Suite licensing rolled out org-wide with SSO and content exclusion baseline
• Initial DORA dashboard for the first golden path, baselining current state

Phase 2 · Self-Service Cloud Resources (months 3–6)

• Crossplane installed on the management cluster; AWS Provider IRSA configured
• First Composition: XPostgreSQLInstance — replaces the most common cloud-resource ticket
• Backstage template extended to scaffold App Repo + GitOps Repo + Crossplane Claim in a single flow
• Subsequent Compositions added by demand: S3 bucket, SQS queue, ElastiCache cluster, Kafka topic
• Claude Code piloted with the platform team and 1–2 stream-aligned teams; pattern library captured

Phase 3 · Durable Workflows & AI Integration (months 6–9)

• Temporal cluster deployed via Helm + ArgoCD; XTemporalNamespace Composition published
• First production workflow ported: a long-running business process currently running on cron + bespoke state
• Claude Code rolled out broadly with MCP servers exposing internal tools (Backstage, Jira, Datadog)
• AI tooling metrics integrated into platform health dashboard — acceptance rates, time saved, team-by-team adoption
• SPACE framework survey baselined; findings drive next-quarter platform backlog

Phase 4 · Optimization & Scale (months 9–12)

• Multi-environment (dev/staging/prod) promotion workflows via ArgoCD ApplicationSets
• Multi-cluster topology if scale demands; AWS Organizations multi-account for blast radius isolation
• Cost showback dashboards in Backstage per team and service — Crossplane tags drive the data
• Platform NPS survey and findings published; backlog prioritized accordingly
• Compliance attestation workflow automated via Temporal — quarterly evidence generated without human toil

📚 What This Builds On

Every concept on this page is grounded in production-shaped work I've already shipped or scars I've already collected.

💡 Lessons Carried Forward

Spec-driven development scales beyond POCs

The Backstage IDP project formalized requirements, design, and correctness properties before any code. That discipline scales: a platform serving 500 engineers needs the same rigor on every Composition, every golden path, every policy. Spec-first means the test suite writes itself and the audit trail is built into the workflow.

The platform team's job is to pay back time

Every minute spent on the platform should pay back many minutes of stream-aligned developer time. The Backstage IDP's 14-service breakeven calculation is the right framing: platform investments are quantifiable, and platform leaders should be willing to defend that math. If a feature can't justify its cost in developer hours saved, it doesn't ship.

AI tooling is a platform capability, not a productivity hack

Provisioning Copilot licenses isn't enough. Integrating AI into golden paths, defining the guardrails, measuring the outcomes, building a prompt library — that's platform work. The companies that get this right will out-ship the ones that just buy seats.

Crossplane and Terraform aren't competitors

Terraform owns the substrate; Crossplane owns the catalog. Trying to do everything in one tool is the classic "when all you have is a hammer" trap. Layering the IaC strategy is the same insight as layering the team topology — different rates of change deserve different tools.

Temporal earns its place by removing brittle alternatives

Every regulated enterprise has cron jobs running multi-day workflows, hand-rolled state machines, and BPM tools nobody understands. Temporal isn't a "new toy" — it's the consolidation of three categories of fragility into one well-operated platform service. The business case is the cron jobs you delete.