About

I design workflows people can trust under pressure.

My work sits between high-performance systems and clinical discipline: make things faster, but never at the expense of clarity, control, or recovery.

Why I work this way

I grew up between two reference points: a Porsche 930 Turbo and emergency medicine. One taught me that power needs control. The other taught me that when pressure rises, clear protocols matter more than improvisation.

Later, as an equine veterinary technician, I learned what continuity of care, logging, and operating discipline actually feel like in the real world. That stays with me in systems work now.

Today that shows up in the kind of workflows I build: fast when they should be, visible when they need review, and recoverable when something goes wrong.

Why the pit-wall analogy fits

Formula 1 is useful here because the engine can change every season while the discipline around telemetry, pit calls, and control surfaces stays durable. That is how I think about CREATE SOMETHING.

  • The 930 taught me that raw speed without handling is a liability.
  • Clinical work taught me that under pressure, trust comes from triage, logging, and clear escalation.
  • The pit wall combines both ideas: fast systems governed by visible calls and recovery discipline.
Pit wall telemetry Control layer active
Race line
01
Intake

Workflow mapped before speed is added.

Telemetry clean
02
Execution

Approvals and handoffs define the live path.

Pit stop ready
03
Release

Artifacts, traces, and recovery keep the lap inspectable.

Red flag if trust breaks
Car
Workflow The operating path

Fast enough to matter. Stable enough to trust.

Driver Client operator

Keeps business context and approval ownership.

Engine Models + tools

Fast-moving stack that can change without rewriting the category.

Chassis Governed workflow infrastructure

The stable control layer that keeps the system on the track.

Telemetry Artifacts + traces

What the team can inspect after launch.

Pit wall
Green flag

Safe actions run

Healthy steps move automatically inside approved bounds.

Pit stop

Risky actions pause

The operator reviews before the workflow creates cleanup.

Red flag

Bad actions stop

A reason, owner, and artifact trail appear immediately.

Swappable engines
ModelsToolkitsConnectorsRuntimes
Stable chassis
ApprovalsRunbooksRelease evidenceRecovery paths

What I do now

Micah Johnson. I am a Senior Systems Architect on the Marketplace Team at Webflow, where I build internal tooling, onboarding systems, and platform infrastructure serving millions of users. The problems are familiar: brittle handoffs, unclear ownership, and systems that look automated until the exceptions show up.

I have shipped integrations across Salesforce, HubSpot, Notion, Slack, Procore, and internal systems. That work informs where native tooling is enough, where MCP is the right wedge, and where approvals, policies, and recovery paths are the difference between a launch and a system people actually trust.

Based in Texas. Working with businesses across the US.

LinkedIn · Email

How I approach the work

Most teams do not need a giant AI initiative first. They need one workflow that stops creating manual cleanup. I start there, then add controls only when the cost of failure justifies the extra layer.

My methodology is the Subtractive Triad: remove duplication, excess, and disconnection before adding automation. Cleaner systems reduce handoff risk. Better constraints make automation more reliable.

The goal is not more automation. The goal is one operating path your team can trust.

How clients experience the work

Clients do not hire me to become another internal admin. They bring the workflow, the operating constraints, and the approval owner. I bring the diagnosis, the control layer, and the artifacts your team needs to run and inherit the system.

Visibility comes through runbooks, approval states, release evidence, and working software, not meeting theater. If what a client needs is a full internal delivery team, I route that work to a better-fit partner.

Timeline

The through-line is not AI. It is learning how to turn messy systems into operating paths people can trust. That pattern shows up in science, creative work, client services, marketplaces, and now automation.

TimelineTools to abstract complexity (and understanding the complexity)2008A&MDomain systems2018WebflowSupport → Education2023MarketplaceOps systems2024Sr Systems ArchData infra2018Create SomethingWeb + APIs2025WORKWAYAutomation infracreatesomething.agency
  1. 2008 – 2010

    B.S. Animal Sciences (Pre-vet track) · Texas A&M University

    Meat science praxis · Animal food science · Feed economics

    • Complexity: Physical systems (anatomy, processing constraints) and economic systems (feed distribution under real-world constraints).
    • Abstraction Tools: Categorization frameworks (cuts/processing), measurement + calculation, and turning messy reality into repeatable procedures.
    • Carry-forward (.agency): Comfort with first-principles detail plus operational clarity: build models that stay true to reality while making it teachable and executable.
  2. 2010 – 2012

    Veterinary Technician (Equine) · Burleson Equine Hospital

    Equine nursing · Blood draws · Farm visits · Clinical logging

    • Complexity: High-stakes clinical work with living systems: patient variability, time-sensitive decisions, and strict safety constraints (animal + human).
    • Hands-on Duties: Equine nursing, drawing blood, administering medication per doctor's orders, assisting on farm visits, and maintaining accurate logs.
    • Abstraction Tools: Protocols, checklists, dosage discipline, and documentation as a single source of truth for continuity of care.
    • Carry-forward (.agency): Operational rigor + traceability: when stakes are real, you design systems that prevent errors, keep humans in the loop, and leave an audit trail.
  3. 2011 – 2013

    Co-owner (Photography Company) · Independent

    Creative production pipeline · First attempt at web development as a service

    • Complexity: High-variance client work: creative direction, production, delivery, and expectation management.
    • Abstraction Tools: Repeatable production workflows: templates, checklists, and “same inputs → predictable outputs” thinking.
    • Carry-forward (.agency): Service instincts: ship outcomes on deadline, communicate tradeoffs clearly, and turn craft into a system clients can trust.
  4. 2014 – 2015

    Digital Content Specialist · Enterprise Holdings

    CMS · SEO · Content operations

    • Complexity: Large-scale content systems: taxonomy, consistency, searchability, and operational maintenance.
    • Abstraction Tools: Content models, publishing workflows, and the discipline of “structure first, copy second.”
    • Carry-forward (.agency): Agent systems need clean information architecture. This is early training in making knowledge queryable and dependable.
  5. 2015 – 2016

    Interactive Developer · Maritz

    Enterprise client web projects

    • Complexity: Shipping inside constraints: stakeholders, timelines, brand standards, and production reliability.
    • Abstraction Tools: Reusable front-end patterns, component thinking, and pragmatic engineering tradeoffs.
    • Carry-forward (.agency): Client work is constraint work. You get good by choosing what not to build and making the rest robust.
  6. 2016 – 2018

    UI Designer & Web Manager · Hunter Engineering

    Led web team · UI/UX design · Public sites

    • Complexity: Bridging product reality to user experience: constraints, stakeholder needs, and long-lived public surfaces.
    • Abstraction Tools: UI systems, standards, and governance: make it consistent so the team can move faster without quality decay.
    • Carry-forward (.agency): A strong interface is an abstraction layer. Same principle applies to agent tooling: reduce cognitive load without hiding truth.
  7. Feb 2018 – Mar 2020

    Customer Support Specialist & Team Manager · Webflow

    500+ user engagements · Onboarding systems · Troubleshooting

    • Complexity: Real-world failure modes: permissions, publishing, integrations, CSS/JS bugs, user mental models, and trust repair.
    • Abstraction Tools: Troubleshooting trees, internal runbooks, and onboarding programs that turn tacit knowledge into repeatable process.
    • Carry-forward (.agency): This is where “tools + explainability” becomes a discipline: show work, leave an audit trail, and design for the next person.
  8. Mar 2020 – Apr 2021

    On-Screen Educator · Webflow

    Webflow University 2.0 · Documentation that links output to inputs

    • Complexity: Teaching at scale: reducing complexity without lying, across wildly different skill levels.
    • Abstraction Tools: Curriculum design, clear mental models, and “explain the system, not the steps.”
    • Carry-forward (.agency): Clients need systems they can understand. Agent work especially needs transparency, guardrails, and a shared vocabulary.
  9. Jul 2023 – Dec 2024

    Marketplace Operations Manager · Webflow

    Template marketplace QA · Operational dashboards · Standards

    • Complexity: Marketplace systems: quality enforcement, creator experience, and scaling review across thousands of assets.
    • Abstraction Tools: Dashboards, checklists, and standards-as-code thinking: turn subjective review into consistent evaluation.
    • Carry-forward (.agency): Operational data becomes intelligence. The value is in the feedback loop, not the one-off report.
  10. Dec 2024 – Present

    Senior Systems Architect · Webflow

    Marketplace data infrastructure · Pipelines (Census/Snowflake/Amplitude/Segment)

    • Complexity: Distributed systems and data reality: events, identity, attribution, and the difference between “data exists” and “data is trusted.”
    • Abstraction Tools: Pipelines, service boundaries, and auditability: design systems where changes are traceable and safe to evolve.
    • Carry-forward (.agency): This is the core .agency muscle: build the connective tissue and the governance so AI can operate safely in real operations.
  11. Nov 2018 – Present

    Webflow & API Developer · CREATE SOMETHING

    Custom development · API integrations · Automation systems

    • Complexity: Integrations live at the edges: mismatched data models, brittle auth, third-party outages, and humans who just need it to work.
    • Abstraction Tools: Webflow + custom code, API-first builds, and automation “glue” that reduces tool sprawl into a single workflow.
    • Carry-forward (.agency): This becomes the delivery backbone: connect systems, preserve auditability, and make automation maintainable (not a pile of zaps).
  12. Jul 2024 – Present

    Co-Founder, Technology · Half Dozen

    Full-stack platform · 10+ service integrations · Multi-tenant operations

    • Complexity: Operational edge cases: schedules, payments, compliance, and the human messiness around live events.
    • Abstraction Tools: Integration architecture, permissioning, and reliability patterns for systems that must keep running.
    • Carry-forward (.agency): Deep integration work: it’s not the API call, it’s the lifecycle. This is where “connectivity layer” becomes real.
  13. Apr 2025 – Present

    Founder · WORKWAY

    Workflow marketplace · Knowledge graph architecture · Edge infrastructure

    • Complexity: Compound automation: multi-step workflows, failure recovery, and progressive autonomy (humans stay in control).
    • Abstraction Tools: Workflow primitives + marketplace structure: turn “custom automation” into composable building blocks.
    • Carry-forward (.agency): This becomes the productized expression of the service: patterns that are stable enough to sell and safe enough to trust.

The rest of CREATE SOMETHING

CREATE SOMETHING operates as a connected system. Each property has a distinct job, and each one sharpens the others:

  • .ltd — Philosophy and principles
  • .io — Research and validated patterns
  • .space — Tools and experiments
  • .agency — Governed workflow infrastructure, reliability controls, and enterprise extension (you are here)

Client work informs the research. Research sharpens the methodology. The methodology raises the bar on client work.

Also building

I am also building WORKWAY. When clients need fuller system development and onboarding than .agency is meant to carry, I provide a direct referral path to trusted partners, including Half Dozen.

Bring the workflow your team still watches too closely.

In one session, I will map the handoffs, approval points, failure modes, and first safe wedge.