About

I build operating systems for autonomy.

I started by connecting business tools to AI — Salesforce, HubSpot, Notion, Procore, and custom systems. That work clarified where value compounds: not at basic connectivity, but at reliability, governance, and system design for real operations.

The approach

CREATE SOMETHING .agency runs a POLICY OS for production autonomy. I build custom workflow MCPs, then layer Autonomy Assurance (evals, policy controls, incident loops) and Enterprise Extension when requirements exceed standard tooling.

My methodology is the Subtractive Triad: before building anything new, I audit your systems to find what should be removed — duplication, excess, disconnection. What remains is what's worth automating. This is why the systems hold up in production: the architecture is designed before capabilities are added.

Background

Micah Johnson. System Architect on the Marketplace Team at Webflow — building internal tools, onboarding systems, and platform infrastructure serving millions of users. Focused on technical architecture for production agent systems.

I have deployed production integrations connecting tools like Salesforce, HubSpot, Notion, Slack, Procore, and custom internal systems to AI. That building experience informs where to trust native tooling and where to design custom control layers.

Based in Texas. Working with businesses across the US.

LinkedIn · Email

Timeline

The through-line: using tools to abstract complexity while still understanding the complexity underneath. That pattern shows up in science, creative work, client services, marketplace systems, and now AI integrations.

TimelineTools to abstract complexity (and understanding the complexity)2008A&MDomain systems2018WebflowSupport → Education2023MarketplaceOps systems2024System ArchitectData 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

    System 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 system behind the work

CREATE SOMETHING operates as a connected system — each part informs the others:

  • .ltd — Philosophy and principles
  • .io — Research and validated patterns
  • .space — Tools and experiments
  • .agency — POLICY OS, Autonomy Assurance, and enterprise extension (you are here)

Client work informs the research. Research refines the methodology. The methodology improves the client work. Every part serves the whole.

Also building

I am also building WORKWAY. When clients need full system development and onboarding as the primary engagement, I provide a direct referral path to trusted partners, including Half Dozen.

Need trust you can inspect?

Book Mapping Session → How I work →