By Doug Silkstone — 10 Mar 2025

Please—Someone—Build "Storybook For Automations"

Photo by Vinicius "amnx" Amano / Unsplash

Note: I'm sharing this early concept of FlowBlocks—a component registry for automation I'm developing—to gather feedback—especially if you're already adopting automation in your organization. If you have thoughts on how this could better serve your needs, I'd love to hear from you - doug@withseismic.com

The rush to adopt automation and AI has created a new problem: a messy proliferation of disconnected tools and workflows that dilute strategic impact. What's missing? A structured approach to making automation components discoverable, reusable, and governed across organizations.

That's why I'm floating the idea FlowBlocks (working title)—a modular, encyclopedic approach to creating, using, and sharing your automation with your whole company, no matter what tools they use. It's Storybook, but for Automation.

TL;DR

Write code blocks that take an input, the code to run, and an output. Give them a definition, and some documentation, and that's it.

These Code Blocks could be things like sending an email, or creating a Jira ticket. Others might pull your best selling products from your Shopify Store, fetch overdue invoices from Stripe, or connect to a database and run SQL.

You can bundle Code Blocks together to make Components (or not, it's up to you), and create a Lego-style ecosystem for building automations in any platform. Flexibility is key - if someone builds a workflow in n8n, they can register that flow as a Component, too; making it usable in code. If you want to convert your N8N to code, you can do, and vice versa. That's the power of blocks.

These Components get saved to a registry, which generates a production-ready Queue, API endpoint, NPM Package, and N8n/Make.com Nodes.

The aim is that developers and no-code users across all your teams have access to your business data & your automated processes—the building blocks for adopting automation properly.

Everything makes more sense with a sequence diagram

Why We Need a Better Solution for Automation Components

We're in an unprecedented era for automation adoption, with 77% of IT professionals considering it essential to their operations. Organizations are rushing to implement both simple task automation and complex intelligent systems. The results can be impressive—US Acute Care Solutions automated processing of 20 million medical records annually, saving over 100,000 hours of work.

But there's a critical problem: Most automation efforts remain isolated, undocumented, and difficult to scale. While workflow automation platforms like make.com and n8n have gained significant market traction with hundreds of thousands of organizations, they focus primarily on workflow creation rather than component modularization and standardization.

What's missing is the equivalent of what Storybook did for UI components: a structured approach to creating, documenting, testing, and sharing automation components across the organization.

Introducing FlowBlocks: A Component Registry for Automation

FlowBlocks is a comprehensive platform I'm developing that enables modular, discoverable, testable automation blocks. It combines component documentation, testing interfaces, and integration mechanisms in one cohesive system.

Think of it as the central nervous system for your organization's automation efforts—a place where teams can:

Discover existing automation components
Understand exactly how to use them
Test them interactively
Integrate them into their own workflows

Just as Storybook revolutionized UI component development by providing "a frontend workshop for building UI components and pages in isolation," FlowBlocks provides a workshop for building, testing, and documenting automation components in isolation.

The Pain Points: Why Current Approaches Fall Short

Current automation approaches face several critical limitations:

1. Isolationist Development

Automations are created in isolated silos without visibility across teams. At Appolica, engineers found that while tools like GitHub Copilot and Codeium boosted individual productivity, there was no systematic way to share these automation wins across the organization.

2. Redundant Efforts

Without a central registry, teams repeatedly build similar automation solutions independently. This redundancy wastes resources and creates inconsistent approaches to solving the same problems.

3. Integration Headaches

Manual integration efforts cause slowdowns and increase dependencies. As Red Hat's research highlights, "six of the 10 barriers cited in the survey were people-culture oriented barriers, not technical ones," with lack of training and fear of replacement being significant obstacles.

4. Documentation Deficit

Poor documentation makes reuse challenging, causing inefficiencies and frustration. Despite the availability of tools like Swagger/OpenAPI for API documentation, the integration between automation tools and documentation standards is not well established.

The FlowBlocks Solution

FlowBlocks addresses these pain points through a structured framework built on four key principles:

1. Grassroots Empowerment

Employees can easily create, identify, and document automation opportunities. This aligns with successful approaches seen at companies like Roo, where CTO John Stearns found that by "leveraging AI tools effectively, they could double the number of product squads without significantly increasing engineering headcount."

2. Systematic Integration with a Lego Block Philosophy

Automation components are designed as modular, reusable blocks that work together seamlessly—like Lego pieces. This modular approach ensures components are:

Discoverable: Easy to find in a central registry
Reusable: Designed with clear inputs and outputs
Testable: Can be validated independently before integration
Documented: Include comprehensive usage guides

3. Component Registry: The Heart of the System

The component registry serves as the central nervous system of your automation strategy, providing:

Discovery: Makes components findable without reinventing the wheel
Documentation: Provides clear schemas for inputs and outputs
Governance: Manages versioning, ownership, and component lifecycle
Integration: Generates endpoints and connection points automatically
Access Control: Ensures proper security and permissions

Each component in the registry is defined with:

Clear input/output schemas
Usage documentation and examples
Version history and compatibility notes
Owner and support contact information
Performance characteristics and limitations

4. Interactive Testing and Cloud Exposure

Automation components are exposed through Swagger UI for immediate testing and ngrok for secure cloud access. This enables:

Real-time testing of components without complex setup
Secure exposure of local services for integration testing
Dynamic generation of public URLs for cloud service integration

What FlowBlocks Helps Teams Do

FlowBlocks transforms how teams work with automation:

For Employees

Simplify automation discovery: Find existing solutions instead of building from scratch
Accelerate implementation: Use pre-built components that work together
Reduce learning curve: Clear documentation makes adoption easier
Test with confidence: Interactive interfaces to validate behavior before integration

For Technical Teams

Standardize approaches: Establish consistent patterns for automation
Reduce duplication: Prevent multiple teams from solving the same problem
Improve quality: Tested, documented components reduce errors
Scale effectively: Components designed for reuse enable rapid expansion

For Executives

Strategic alignment: Connect automation to business objectives
Measurable impact: Clear metrics on component usage and value
Faster time-to-market: Modular approach accelerates implementation
Cost efficiency: Reusable components reduce redundant development

Technical Implementation

FlowBlocks relies on several key technologies:

TypeScript/Zod: For schema definition and validation
Next.js/NestJS/Fastify: For endpoint generation and API hosting
Swagger/OpenAPI: For documentation and interactive API exploration
ngrok: For public endpoint tunneling and cloud access
n8n: For workflow creation and execution

A typical workflow might look like:

Define a component with clear input/output schemas
The system automatically generates API endpoints and documentation
ngrok creates a secure tunnel for external testing
Swagger UI provides an interactive interface for testing
n8n integration templates are generated for easy workflow incorporation

Glossary of Key Terms

Automation Component: A group of related code blocks with defined input schemas, outputs, documentation, and handlers.
Code Blocks: Individual, reusable snippets or logic modules used to build automation components.
Component Registry: Centralized repository listing automation components, their schemas, documentation, and integration endpoints.
n8n: An open-source, node-based automation tool that enables workflows through a visual interface, facilitating no-code integration.
Swagger/OpenAPI: Tools used for documenting APIs, providing interactive exploration, and real-time testing capabilities.
ngrok: Service for creating secure tunnels, exposing local server endpoints securely and publicly for testing and integration.

Measuring Success

The impact of FlowBlocks can be measured through:

Component reuse rate: How often components are shared across teams
Time savings: Workflows compressed from days to minutes
Adoption metrics: Number of users actively using the registry
Integration speed: Time required to incorporate components into workflows
Cross-functional usage: Components used across department boundaries

Bridging the Gap Between Strategy and Execution

The most powerful aspect of the FlowBlocks approach is how it bridges the gap between high-level strategy and ground-level execution—a key challenge identified in automation initiatives.

Perspective	Traditional Challenge	FlowBlocks Solution
Executive (Macro)	Strategic initiatives disconnected from implementation	Clear traceability from components to strategic objectives
Management (Meso)	Difficulty standardizing approaches across teams	Centralized governance and component registry
Employee (Micro)	Reinventing solutions that may exist elsewhere	Discoverable components with clear documentation

This bridging function is what sets FlowBlocks apart from other approaches. It connects the dots between an executive's strategic vision and an employee's daily productivity needs.

Conclusion: A Call for Feedback

As I continue developing FlowBlocks, I'm actively seeking feedback from automation practitioners, team leads, and executives who face these challenges.

What aspects of FlowBlocks would bring the most value to your organization?
Are there specific features or integrations that would make it essential for your teams?
What challenges do you anticipate in implementing such a system?

By implementing a FlowBlocks approach, organizations can transform their automation efforts from isolated, redundant initiatives into a cohesive, scalable system that delivers measurable business impact.

I believe the time to build your organization's automation component registry is now. The alternative? Watching your automation efforts remain fragmented, undocumented, and underutilized—a fate no forward-thinking organization can afford in today's competitive landscape.

I'd love to hear your thoughts on FlowBlocks! Reach out in the comments or directly to discuss how this concept could evolve to better serve your organization's needs.

I'm excited to share FlowBlocks—a component registry for automation I've been working on—to get some early feedback from folks in the automation community. If you've ever felt the pain of reinventing automation wheels or hunting down undocumented workflows, I'd love to hear your thoughts!

After spending years watching organizations struggle with disconnected automation tools and siloed workflows, I decided it was time to build something better. The problem was clear: we're all rushing to adopt automation and AI, but we're creating a mess of disconnected tools that nobody can find, use, or maintain. That's why I'm building FlowBlocks—a way to make automation components discoverable, reusable, and actually useful across your entire organization.

The Automation Mess We're All Living In

Let's be honest—we're all drowning in automation tools. According to research, 77% of IT professionals consider automation essential to their operations. We've seen amazing success stories like US Acute Care Solutions automating 20 million medical records and saving 100,000 hours annually.

But here's the problem I keep seeing: all these automation efforts exist as islands. You build something awesome, and then what? It sits in your department, undocumented, while someone three desks away builds the exact same thing from scratch.

Like you, I've watched platforms like Microsoft Power Automate and n8n gain traction, but they don't solve the fundamental problem—how do we create a shared library of automation components that everyone can use?

I found myself asking: Why can't we have for automation what Storybook did for UI components? That's the spark that led to FlowBlocks.

What's FlowBlocks? My Take on Fixing Automation Chaos

FlowBlocks is my answer to this problem—a platform that makes automation components modular, discoverable, and testable. Think of it as your organization's automation library where anyone can:

Find automation components others have already built
See exactly how to use them (with actual documentation!)
Test them right there in the browser
Plug them into their own workflows

I've been obsessed with how Storybook transformed UI development by letting us build and test components in isolation. FlowBlocks brings that same philosophy to automation workflows.

The Headaches We're All Experiencing

If you're like me, you've probably banged your head against these same walls:

The "Who Built This?" Problem

How many times have you discovered that three different teams built nearly identical automations because nobody knew what already existed? At a previous company, I watched engineering teams build GitHub Copilot and Codeium integrations over and over again, with no way to share what worked.

The Redundancy Nightmare

You finally nail that perfect integration between your CRM and billing system, only to learn that another team did the same thing last quarter—and theirs handles edge cases yours doesn't. Sound familiar?

The Integration Dance

As the Red Hat research pointed out, "six of the 10 barriers to automation were people-culture oriented, not technical ones." I've lived this—spending weeks trying to integrate with someone else's automation because they've moved on and nobody documented how it works.

The Documentation Desert

Even with great tools like Swagger/OpenAPI for APIs, I've rarely seen teams properly document their automation components. We're all guilty of the "I'll document it later" promise that never happens.

How FlowBlocks Fixes These Problems

After experiencing these pain points firsthand, I've built FlowBlocks around four principles I believe can transform how we handle automation:

1. Make Automation Accessible to Everyone

I want everyone in your organization to easily create, find, and use automation components. I was inspired by what Roo's CTO John Stearns achieved, where "leveraging AI tools effectively let them double the number of product squads without significantly increasing engineering headcount."

2. Build Automation Like Lego Blocks

Remember how satisfying it is to snap Lego pieces together? That's how automation should work. Each component in FlowBlocks is designed as a modular, reusable block with:

A find-me-easily design so anyone can discover it
Clear inputs and outputs so you know exactly what it needs and gives
Built-in testing so you can validate it works before integrating
Actual documentation (I know, revolutionary concept!)

3. Create a Central Library Everyone Uses

The heart of FlowBlocks is the component registry, which serves as your organization's single source of truth for automation. It handles:

Finding stuff: No more "I think Sarah built something like this once..."
Understanding stuff: Clear documentation of what each component expects and returns
Managing stuff: Version control, ownership, and lifecycle management
Connecting stuff: Automatically generated endpoints and connection points
Securing stuff: Proper access controls so the right people can use the right components

4. Make Testing and Integration Painless

I've integrated Swagger UI for instant testing and ngrok for secure cloud access because, let's face it, testing automation components shouldn't require an engineering degree.

What FlowBlocks Will Do For Your Team

I'm building FlowBlocks to transform how your teams work with automation:

For You and Your Colleagues

Find stuff fast: Discover existing solutions instead of building from scratch
Build stuff faster: Use pre-built components that work together
Learn stuff easier: Clear documentation makes adoption painless
Trust stuff more: Test components before you integrate them

For Your Technical Teams

One way to solve problems: Establish consistent patterns for automation
Stop rebuilding the wheel: Prevent multiple teams solving the same problem
Fewer bugs: Tested, documented components mean fewer errors
Scale without pain: Components designed for reuse enable rapid expansion

For Your Leadership

Connect to strategy: Link automation directly to business objectives
See actual impact: Clear metrics on component usage and value
Move faster: Modular approach accelerates implementation
Save money: Reusable components reduce redundant development

How I'm Building It

I'm building FlowBlocks using technologies I believe strike the right balance between power and accessibility:

TypeScript/Zod: For rock-solid schema definition
Next.js/NestJS/Fastify: For fast, reliable endpoints and APIs
Swagger/OpenAPI: For documentation you'll actually use
ngrok: For secure tunneling without the network pain
n8n: For creating workflows people actually understand

Here's how I envision you using FlowBlocks:

Define a component with clear schemas (don't worry, the interface makes this easy)
The system automatically creates API endpoints and documentation
Ngrok sets up a secure tunnel for testing from anywhere
Swagger UI gives you a playground to test your component
N8n templates are generated so anyone can use your component

Quick Glossary Because Jargon Is Annoying

Automation Component: A reusable piece of automation logic with defined inputs and outputs
Code Blocks: The individual building blocks that make up a component
Component Registry: Your central library of available automation components
n8n: An open-source automation tool with a visual interface
Swagger/OpenAPI: Tools for documenting and testing APIs
ngrok: A service that creates secure tunnels to your local environment

How You'll Know It's Working

When FlowBlocks is successfully implemented in your organization, you'll see:

People reusing components instead of building new ones
Workflows that used to take days completed in minutes
More people across different teams using automation
Faster integration of components into new workflows
Components being shared across departments that never collaborated before

Connecting Strategy to Execution

What I'm most excited about is how FlowBlocks bridges the gap between high-level strategy and the day-to-day work:

Level	Current Frustration	How FlowBlocks Helps
Executive	"Why aren't our strategic initiatives being implemented?"	Components directly trace back to strategic objectives
Management	"Why is every team doing things differently?"	Centralized governance creates consistency
Individual	"I know someone built this already, but I can't find it!"	Discoverable components with clear documentation

This is what makes FlowBlocks different—it connects what your executives want with what your employees need to do their jobs.

I Want Your Feedback!

I'm building FlowBlocks because I've lived with these automation headaches, and I bet you have too. Now I need your help to make it better:

Which of these problems resonates most with your experience?
What features would make FlowBlocks a must-have for your organization?
What challenges do you see in getting people to adopt something like this?

I truly believe that by taking a more structured approach to automation components, we can transform isolated, redundant initiatives into a cohesive system that actually delivers results.

The alternative? More of the same chaos we've all been living with—fragmented automation efforts that nobody can find, use, or maintain. And I don't know about you, but I've had enough of that.

Reach out: doug@withseismic.com / linkedin.com/in/dougsilkstone

I'd love to hear your thoughts on FlowBlocks! Drop a comment or shoot me a message—your feedback will directly shape what this becomes.