Two halves. Cloud and platform engineering is most of what we have built: estates, clusters, networks, and the delivery paths through them.
AI systems sit on top of it, and only work because of it.
Most of what we have built is here: estates, clusters, networks and the delivery paths through them. Work that has to keep running on a Tuesday morning when nobody is watching it.
Migration and re-architecture across AWS, Azure and Google Cloud: hybrid and multi-cloud estates, private cloud, and the bare-metal provisioning automation beneath. Landing zones and organisation structure, infrastructure as code from the account boundary down, and datacentre exits where the workloads were never written down and the inventory has to be established before anything moves.
Managed and self-hosted clusters and the platform around them: workload and namespace design, autoscaling and capacity, service mesh, ingress, and the admission policy that decides what is allowed to run. Migrations onto Kubernetes, and, where a cluster turned out to be the wrong answer, off it.
Shared VPC design and address planning, public and internal DNS with zones kept under version control, NAT, VPN and interconnect, load balancing, and the firewall and WAF rules in front of all of it. Usually the first thing a migration turns out to depend on.
Machine identity and workload federation instead of long-lived keys, secrets fetched at runtime rather than baked into an image, certificate and key management, and policy as code in the admission and deploy path. Least privilege that is actually enforced rather than documented, and fail-closed defaults, so a misconfiguration stops the system instead of quietly opening it. We also test it the way an attacker would: penetration tests and security assessments of applications, APIs and cloud estates, under written authorization, with the fixes as well as the findings.
Service level objectives with error budgets that gate a release rather than decorate a dashboard, on-call rotation and incident response, and the metrics, logs and traces underneath them. We have built the function from nothing as well as joined one already running.
Recovery objectives written as numbers somebody has agreed to, and then the design that actually meets them: backups restored on a schedule rather than assumed, failover exercised rather than diagrammed, and a dependency map that says what has to come back first. We would rather establish what you can currently recover than assert what you could.
Where the spend actually goes, at the level of a service rather than a monthly invoice: committed use and rightsizing measured against real utilisation, egress and inter-region traffic, storage class and retention, and the cluster requests nobody revisited after the first deploy. Cost and performance come off the same measurements, so we do them together instead of trading one against the other.
Internal developer platforms and golden paths, plus products that simplify the operation and observability of the platform beneath: network, compute and storage. Tooling your engineers reach for because the friction is gone.
Warehouses, streams and the pipelines between them: provisioning for managed databases, messaging and analytics, schema and contract checks in the delivery path, and the migrations between stores. Built so the data a decision rests on has a lineage somebody can follow.
APIs, platforms and services built with clean seams, made to hold their edges for years.
Reviews, blueprints and system design: the enduring pattern, drawn once and drawn correctly. Includes the unglamorous version: an assessment of an estate you have inherited, written so you can forward it to somebody who was not in the room.
The newer half, and the one that only works because of the half above it. An agent is a distributed system with a model in it, and it fails the way distributed systems fail.
Autonomous agents, tool-use, and multi-agent orchestration, wired into the workflows you actually run. Observable, evaluated, and accountable for what they do. This is the core of what we do.
Model applications, retrieval and content generation, shipped with evaluation you can read rather than a demo you have to trust.
Custom workflow and process automation, wired into where teams already work, so a process stays visible while it runs instead of vanishing into a black box.
Models, analytics and decisioning that turn a stream of signal into something a person can act on.
Two disciplines, kept distinct. MLOps is the operational layer beneath the models and agents: versioned pipelines, a registry, retraining on drift, and evaluation gates in the deploy path. AIOps is AI turned back on the systems themselves: anomaly detection across metrics, logs and traces, correlation that collapses an alert storm into one incident, and root-cause analysis that names the fault rather than the symptom.
Grouped by discipline, because that is usually what you are looking for. Everything named on a project appears in this list, and so does a good deal that predates them.
Estates on all three, and the migrations between them.
Address plans, DNS, egress and edge. The layer that is invisible until it is wrong and then is the only thing anyone can talk about.
Metrics, logs, traces and the alerting on top of them, built so an on-call engineer is paged by a symptom a user would recognise.
Build and release paths, including the ones that had to be replaced while still running.
Cluster and infrastructure state reconciled from version control, so the repository is the system of record rather than a description of it.
Workloads, the clusters under them, and the policy that decides what is allowed to run.
Provisioning and configuration as code, from bare metal upward. Two generations of it, because estates rarely contain only one.
Service catalogues, golden paths, release automation and the internal tooling engineers reach for because the friction is gone.
Stores, queues and pipelines, including the migrations between them.
Secrets, certificates, machine identity and the way people reach production, kept out of the code and out of the image.
Testing a system the way an attacker would, under written authorization, and the code and dependencies it is built from: reconnaissance, exploitation and injection, and the fixes that close what was found.
Model platforms and agent runtimes, with the evaluation and delivery path around them.
Hypervisors, HPC schedulers, storage and bare-metal provisioning. The estate that predates the cloud and in most places is still running.
What the work is written in, and what builds and runs it.
Frameworks and the third-party services the applications sit against.
Fig. 27What the index is a list of
The names above are the parts. This is the shape they are usually in when we are called: clusters that grew separately, each one reasonable on its own, all of them routed through a single element nobody owns. The work is rarely replacing the parts. It is making that element legible, and then making it something other than a single point of failure.
If any of this is the work you need doing, the next step is one call, about ninety minutes.