KYLEKILMETISALPHA

Google Cloud Certified · Profile

Principal altitude, by practice.

This is the current state of my engineering evolution. I work across the Google Cloud estate and hold three Google Cloud professional certifications: Professional Cloud Architect, Professional Cloud Security Engineer and Professional Cloud Network Engineer. They validate the architecture, security and networking ground. Beyond them, I study and build data systems, agent infrastructure, knowledge systems and autonomous delivery for myself—daily, experimentally and in working software.

I am not building toward a static list of capabilities. I am building one connected system of thought and machinery: infrastructure into platforms, platforms into agents, agents into memory, memory into autonomous work, and autonomous work back into human creation.

The atlas is hands-on: thirteen interactive systems to operate →
Google Cloud Certified
  • Professional Cloud Architect
  • Professional Cloud Security Engineer
  • Professional Cloud Network Engineer

  • Professional Cloud Architect

    Stands behind the estate as a whole: landing zones, platforms, delivery. See it →

  • Professional Cloud Security Engineer

    Stands behind the six control planes beneath every workload. See it →

  • Professional Cloud Network Engineer

    Stands behind the connectivity fabric, hybrid and the edge. See it →

Where they stop · Data, AI, agent infrastructure and autonomous delivery are self-taught: studied, used daily and proven in systems I build and run myself.

What I build

The estate, whole.

I own the shape of an estate, not a slice of it. The network a new team joins by declaring intent. The six control planes beneath every workload, each enforced by the platform and closed by a proving test. The platforms that ship by policy and slow down by budget. The agents with a job description, the knowledge graph that keeps a decision joined to its evidence, and the delivery factory that turns an architecture into a verified repository.

Systems atlas

My current state of engineering, made explorable.

Seven layers, each with a working diagram, eighteen step-through workflows and seven drafted sheets with their failure drills. Every diagram responds; nothing in it is an inventory.

Enter the stack →
  1. 00Cloud foundations
  2. 01Security & posture
  3. 02Reliable platforms
  4. 03Agentic systems
  5. 04Knowledge & memory
  6. 05Autonomous delivery
  7. 06People and decisions

How I work

Principal altitude is a way of working.

Principal altitude is how I hold the whole estate in view: every layer, every seam, every enforcing mechanism and every proving test.

Draw the system until the shape is obvious. Let the platform enforce the rule and name the mechanism. Call nothing done on a feeling. Keep every change intent until policy and a person have passed it, and keep the way back open until verification is signed.

Five tenets, each with its proof on the atlas

  1. 01

    Shapes before recipes

    Draw the system until its shape is obvious: boundaries, planes, paths and decisions. Implementation details come later and remain private.

    Proof · Every diagram on this site is a shape that responds; no inventory, range or identifier appears anywhere. See it →

  2. 02

    The platform enforces; documents do not

    Every rule names the platform mechanism that enforces it. If the platform only observes it, the design says so plainly.

    Proof · The security blueprint: every control with its mechanism, proving test and owner. See it →

  3. 03

    Nothing is called done on a feeling

    A control closes only when its proving test passes. A release receives traffic only after verification. The evidence lives beside the claim it proves.

    Proof · The evidence run, the gate ladder and the build graph of this site's own construction. See it →

  4. 04

    Policy before anything is real

    A change remains intent until its plan passes policy, receives the required approval and is applied through the governed path. After release, the error budget sets the pace.

    Proof · The delivery pipeline and the error budget, worked month by month. See it →

  5. 05

    Reversible by construction

    Build the new path before closing the old one. Keep the way back open until verification is signed, with rollback designed and tested as part of the change.

    Proof · The two-estates pathway with its readiness gate, and a deploy that promotes only after the candidate is verified. See it →

Vision and mission

Unleash creation. Govern promotion.

I see one unbroken line: cloud infrastructure becomes reliable platforms, platforms become agentic systems, agentic systems acquire memory, memory enables autonomous workflows, and autonomous workflows hand the irreducible work back to the human—creativity, judgment and purpose.

  1. 01 · Cloud infrastructure becomes reliable platforms.
  2. 02 · Reliable platforms become agentic systems.
  3. 03 · Agentic systems acquire memory.
  4. 04 · Memory enables autonomous workflows.
  5. 05 · Autonomous workflows return the irreducible human contribution: creativity, judgment, intent and purpose.

Mission

Unleash creation. Govern promotion.

I build governed AI workforces and the factories that produce them, so building becomes repeatable, verifiable and owned by the people it serves. Nothing I ship is finished until something other than its builder says so.

The doctrine

Intent, creation and the gate.

The machinery exists to return us to purpose. Seven questions, answered in my own words, and the system on the atlas where each idea is built.

  1. 01

    The human holds

    intent and the gate.

  2. 02

    The AI holds

    creation.

  3. 03

    Deterministic code holds

    the verdict.

Models propose; code disposes; the human governs promotion.

  1. Q01What is your vision?

    The ascent of man through knowledge, discipline, creation and transformation, carried now by a workforce that does not sleep.

    Continue reading ↓

    I see one unbroken line: cloud infrastructure becomes reliable platforms, platforms become agentic systems, agentic systems acquire memory, memory enables autonomous workflows, and autonomous workflows hand the one irreducible thing back to the human: creativity.

    The machinery exists to return us to purpose. I want intelligence built the way the ancients built their temples: to proportion, to purpose and to last.

  2. Q02What is your mission statement?

    Unleash creation. Govern promotion.

    Continue reading ↓

    I build governed AI workforces, and the factories that produce them, so that the act of building becomes repeatable, verifiable and owned by the people it serves. Nothing I ship is finished until something other than its builder says so.

  3. Q03What excites you most about the current technological landscape?

    The bottleneck has moved. For the whole of my career, the limit was hands: how many engineers, how many hours, how many files one person could hold in their head at once. That limit is gone. The limit now is intent and judgment: knowing what should exist, in what order, and what “done” means. Those were always the rare skills. Now they are the only ones that matter.

    Continue reading ↓

    And underneath that, something quieter and larger: memory is arriving. Systems that improve with experience, that carry the record forward, that learn the shape of a domain and keep it. One person with a method and a record can now run what used to take a department. A single man can command a legion.

  4. Q04What do you believe is the ideal workflow dynamic between human and AI?

    The human holds intent and the gate. The AI holds creation. Deterministic code holds the verdict. Models propose; code disposes; the human governs promotion.

    Continue reading ↓

    I do not review every line, and I do not want to. I define what must be true, I set the oracle that can falsify it, and I decide what crosses into production. Between those two points the agents run free, because constraint belongs at the gate, not around the forge.

    When the work is large enough for a swarm, the rule is: share intent, isolate context, gate the collective act. It is less pilot and copilot than architect and legion. I do not carry the stones. I decide where the walls go, and I inspect the receipt.

  5. Q05When you build, how do you determine functionality?

    Backward from the terminal condition. Before any code, I write what must be true at the end: a production receipt that can only be issued by something other than the builder. Then I write what would prove it false.

    Continue reading ↓

    Functionality is whatever is required to make the receipt true, and nothing that is not. From there the logic runs macro to micro to macro: the whole, reduced to its smallest buildable parts in dependency order, then recomposed and demonstrated as the whole. A feature that does not trace back to the receipt is decoration, and decoration is debt.

    Implemented is not complete. Tested is not complete. Merged is not complete. Deployed is not complete. Verified by someone who did not build it: that is complete.

  6. Q06How do you choose the projects you decide to work on and build?

    Two tests. Does it compound, and does it serve both the macro and the micro—the long thesis and the thing in front of me this week?

    Continue reading ↓

    I prefer to build the factory over the artifact, but I know my own failure mode: the forge is seductive, and the sword is what pays. So the rule is that every factory must ship a real deliverable before I am allowed to build the next one.

    I build for myself first. The workforce I sell is the workforce I run; if I would not use it, I do not trust it, and I will not ask you to.

    And I keep one foot in antiquity—in myth, Rome and philosophy—because the old problems are the same problems. Only the tools changed.

  7. Q07What would you be willing to build for someone else?

    Anything I would be willing to govern afterward.

    Continue reading ↓

    Governed AI workers for a business with real work to do: intake, follow-up, scheduling, records—the hours that bleed. Built as configuration on a shared codebase, so each one deploys repeatably and comes with a runbook the owner can follow without an engineer in the room.

    An operations platform for a domain you know better than I do. An assessment of your cloud estate that shows where everything lives and how it connects. A pipeline that turns your knowledge into published volumes. Or the method itself: I will build you the factory and teach your people to run it.

    What I will not build is a demo that has to be rebuilt to become real. Everything leaves with a receipt.

Where each idea is built

How I build

End first. Structure second. Creation unleashed. Proof from outside.

Physics gave me the method, philosophy the order of the questions, and Rome the operational layer. Each movement ends in the system where it runs.

  1. 01Terminal conditionWhat must be true at the end, written so it can be falsified.
  2. 02System boundaryThe matter as it is: what is inside, what crosses, what must survive.
  3. 03ArchitectureThe form, laid out whole before any part exists; it fixes the build order.
  4. 04BuildersCreation unleashed: agents work freely inside isolated walls.
  5. 05Independent gateA verdict the builder does not get to grade.
  6. 06Production receiptIssued only when the measurement that could have failed did not.
  7. 07Method improvementEvery build improves the method; the improvement ships with the next build.
The last stage feeds the first: every receipt improves the method that writes the next terminal condition. Select a stage to see where it runs.

The way I was taught to think, twice over.

Physics gave me the method: define the system and its boundary, write down the initial conditions, name the invariants that must survive every transformation, and accept that no claim is true until a measurement that could have killed it has failed to.

Continue reading ↓

Philosophy gave me the order of the questions: what is the thing, what is it for, and what would count as having it?

Aristotle said that anything which comes to be has four causes: the matter it is made from, the form it takes, the agent that makes it, and the end it is made for. I build in that order reversed.

The end comes first, written down precisely enough to be falsified. Then the matter as it actually is, not as I wish it were. Then the form, which is the architecture. Only then the agent—and that is where the AI enters.

The AI is the efficient cause. It supplies the labor of creation at a scale no team of hands could match, and I let it work without standing over it, because constraint belongs at the end, where the claim meets its measurement, not at the beginning, where it would only suppress creation.

What leaves my hands is not something I believe works. It is something that has been demonstrated to work by a measurement the builder did not get to grade.

The Greeks had a word for that: apodeixis—demonstration, as opposed to persuasion. I was trained to accept only the first.

Then structure.

A Roman army on the march built the same camp every night, to the same plan, in the same order: the surveyors set the two axes first, the commander’s tent at their crossing, the streets and gates from there, and only then the tents.

Continue reading ↓

Polybius said a soldier entering camp knew his place as a citizen knows his own city, and he could find it in the dark, because the structure was the instruction.

I lay out the whole before any part of it exists, and the layout fixes the order in which the parts are built, so that no builder ever has to guess what comes next.

Physics taught me why this works: the law of motion is the same everywhere, and what makes one system differ from another is its boundary conditions. The structure is the boundary condition of the build.

Philosophy taught me its name: form precedes matter in the order of explanation. The architecture is the formal cause, and the matter is poured into it, never the other way around.

This is macro to micro: the whole descending into its parts, in order.

Then I unleash creation.

The builders run without me standing over them, because I do not constrain building; constraint lives at the gate, not at the forge.

Continue reading ↓

When the work is large enough to need many builders, they run the way Rome ran its colonies. A colony carried the form of Rome to new ground: the same grid, the same law, the same magistracies, the same intent. But each governed itself inside its own walls, and no colony reached into another’s affairs.

They were bound to Rome by two things: the road and the record. What one colony needed to know of another, it learned from the tablets on the Capitol, not from the other colony’s mouth.

One magistrate held a given authority at a time, and he held it for a term, after which his claim on it expired. The larger the act, the larger the body that had to consent to it: a magistrate could settle a dispute, the Senate could decree, but war required the whole people assembled.

Physics says the same with fewer words: bodies interact only through what crosses their boundaries, interactions are carried by a field rather than by bodies reaching across space, and the more energy an act carries, the more it must be contained.

Philosophy supplies the one distinction that makes the arrangement safe: a claim is something that can be false, and an act is something that cannot be undone.

Claims may travel freely. Acts are gated.

I call this the Colony Postulate. The Romans only called it government.

MOVEMENT 04

The method examines itself

Built as · This site's own build manifest →

And then the recursion, which is the part I am proudest of.

Every fifth year, Rome turned its own instrument upon itself: the censors counted the city, ranked it, and closed the count with a rite that certified it. The state audited the state by the same method it used on everything else, and submitted to the result.

Continue reading ↓

I did the same.

The method had to build the method, from its first line to its last, then pass through its own gate and receive its own receipt from an acceptance step that had not watched it being born.

A physicist will recognize why that could not be skipped: the hardest thing to measure in any experiment is the apparatus, and no honest result omits it.

A philosopher will recognize the older reason: a method that cannot survive its own examination is not a method. It is a habit.

It survived.

It is now a skill. Every build improves it, and every improvement ships with the next build.

Knowledge that improves with experience. Machinery that returns us to purpose.

Rome supplies the operational layer in each movement: the camp for structure, the colony for the swarm, the census for recursion. Physics supplies the law. Philosophy supplies the warrant.

Reference designs

Six architectures, each carried from principle to proof.

Each one is written as a reference architecture: what it refuses, what it proves, and the mechanism behind every rule.

  1. 01

    Hub-and-spoke connectivity designed to scale across hundreds of cloud projects

    A reference architecture designed to scale across hundreds of cloud projects. An illustrative multi-hub Network Connectivity Center topology, organized around six representative connectivity domains, with Shared VPC, hybrid interconnect and private service access, so that a new workload joins the network by declaring intent in infrastructure code rather than by opening a ticket.

    GCPnetworkinginfrastructure as codeNCCShared VPCPSCgovernance

    Read →
  2. 02

    Six control planes under every workload

    A reference security architecture for Google Cloud, written as six control planes that every workload inherits, governance, identity, network, edge, data and AI, with the workload platforms adding gates of their own. Each plane names the mechanism that enforces it, the proving test that closes it, and the one place each rule is written.

    GCPsecurity architectureorganization policyIAMCloud ArmorVPC Service ControlsModel Armorgovernance

    Read →
  3. 03

    Two estates, one standard

    A reference strategy for moving an established cloud estate, one shared network serving many projects, into a hub-and-spoke estate, without letting the move become the remedy. Both estates are held to the same catalog of controls; three moves and one gate take a workload from one to the other; and the way back stays open until verification is signed.

    GCPmigrationNetwork Connectivity Centergovernancereadiness gateinfrastructure as codeprogramme design

    Read →
  4. 04

    Tags decide, labels describe

    A reference tag and label model for a cloud estate, in which one record per project is written twice by the pipeline, as tags that controls decide on and as labels that people and reports read, with the firewall's identity derived from the same record and bound on each machine. Who may bind what, under which approval, and the one tag the pipeline never touches.

    GCPResource Manager tagslabelsorganization policyfirewall policyIAM conditionsgovernance

    Read →
  5. 05

    A living model of a cloud estate

    A reference model for moving posture management from a queue of findings to a queryable representation of the estate, so that exposure paths, architectural patterns and evidence are questions you can ask rather than archaeology you have to do.

    GCPsecurity posturegraphevidenceautomationinfrastructure as code

    Read →
  6. 06

    Governed landing pads for workloads

    Kubernetes and serverless containers as the two places a workload is allowed to land, each wrapped in infrastructure-as-code modules that make the secure configuration the default, with observability and runbooks attached before the first deploy.

    GCPKubernetesCloud Runinfrastructure as codeCI/CDobservabilityreliability

    Read →

Self-taught, built and run

The certified ground is explicit. So is the ground I prove through systems of my own.

The three certifications validate the architecture, security and networking ground. Everything past that line is proven the way I prove anything: in systems I build, run daily and submit to a gate I did not write the verdict for.

  • The daily evidence run

    A posture platform whose collector can only read, whose judge cannot see the estate, and whose ledger is the only authority.

    Operate it on the atlas →

  • The constitutional control plane

    Deterministic software owns an agent's permissions, workflow state, approvals and audit; the model only proposes.

    Operate it on the atlas →

The earlier arc

Before the cloud, the pitch.

The operating discipline began in live systems with no maintenance window: make the path legible, test the failure and never call the system ready because it feels ready.

  1. Systems under pressure

    Video-assistant-referee replay systems deployed across professional sports venues: 150+ production servers, operated live through a championship final and two international tournaments. Match day does not have a maintenance window.

  2. The data side

    Sales engineering in data security, translating a threat model into a deployment a customer would actually run.

  3. On my own

    Independent architecture consulting: small teams, real constraints and systems that had to work because there was no second budget.

A separate site · Omega

Application builds and product demonstrations live separately in Omega.

Working applications, product demonstrations and interactive build exhibits live in Omega, a separate project portfolio. Omega · application builds ↗

One page, when you need it.

The résumé is available on request.

Email me