Workflow mapped before speed is added.
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.
Approvals and handoffs define the live path.
Artifacts, traces, and recovery keep the lap inspectable.
Fast enough to matter. Stable enough to trust.
Keeps business context and approval ownership.
Fast-moving stack that can change without rewriting the category.
The stable control layer that keeps the system on the track.
What the team can inspect after launch.
Safe actions run
Healthy steps move automatically inside approved bounds.
Risky actions pause
The operator reviews before the workflow creates cleanup.
Bad actions stop
A reason, owner, and artifact trail appear immediately.
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.
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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).
-
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.
-
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.