The Fork That Started Everything

October 1, 2021. A single commit: chore: Add monorepo setup. The author was Ali BARIN, founder of Automatisch, an open-source Zapier alternative. We didn’t write that commit. We forked it.

That fork became the foundation for everything we’ve built since. Four years, three products, 5,876 commits across our platform. But on that day in October, we were just a team with a thesis: businesses would pay for automation infrastructure they could own and control.

Why fork an open-source project

The build-versus-buy decision is one every engineering team faces. For us, there was a third option: fork and extend.

Automatisch had already solved problems we didn’t want to solve again. The monorepo was clean – an Express.js backend in TypeScript, a React frontend with Material UI and Apollo GraphQL, internationalization via react-intl. PostgreSQL with Objection.js ORM and Knex migrations handled the data layer. BullMQ managed three types of workers: flow, trigger, and action. The plugin architecture was extensible.

Building that from scratch would have cost us six to nine months. The ORM layer alone, with its migration system and relationship management, was weeks of work. The job queue with its retry logic, concurrency controls, and dead letter handling was another month. None of that was our competitive advantage. Our advantage was what we’d build on top of it.

So we forked. MIT license. Clean conscience.

The first 152 commits

The final quarter of 2021 was foundational work. Not glamorous. Not demo-worthy. We were learning the codebase, understanding the plugin architecture, and shipping the first integrations that would prove whether the platform could scale.

Slack was first. Then Twitter. Then Scheduler – a trigger that fires on a cron expression, which sounds simple until you’re handling timezone edge cases across distributed workers.

Those three integrations taught us the pattern: every plugin needs an authentication handler (usually OAuth2), a set of triggers that listen for events, a set of actions that execute operations, and test run support so users can verify their setup before going live. We’d repeat that pattern 165 more times over the next four years.

By December 2021, we had 152 commits and a working platform that could chain triggers and actions across a handful of services. Not competitive with Zapier. Not even close. But functional, self-hosted, and ours to extend.

2022: The integration grind

The year that followed was the most unglamorous stretch of our entire journey. 1,069 commits, and the majority were integration work.

Q1-Q2 2022 was the productivity push. Google Sheets, Gmail, Discord, Telegram, Notion, Trello, Twilio, DeepL. Each integration had its own OAuth dance, its own rate limiting quirks, its own pagination patterns. Google’s API alone required understanding their token refresh flow, scope management, and the difference between service account and user-level authentication.

Q3-Q4 2022 was about making the platform production-ready. Multi-user support with proper access controls. OAuth2 connection management so users didn’t have to re-authenticate every session. Stripe integration for billing. Salesforce and HubSpot for the CRM crowd. A CLI tool for headless management. The Datastore feature for persistent state between workflow runs. Flow templates so new users didn’t start from a blank canvas.

The Automatisch community was active during this period. Hundreds of commits from contributors who cared about the open-source project for their own reasons. Bug fixes, documentation, edge case handling. That community effort gave us a solid base to build on. We weren’t maintaining the entire codebase alone – at least not yet.

The bet on self-hosted

Every technical decision we made in those first two years was shaped by one conviction: businesses want to own their automation infrastructure.

This wasn’t a popular take in 2021. Zapier had won the no-code automation market. Make (formerly Integromat) was growing fast. The consensus was that cloud-hosted, pay-per-task platforms were the future.

We saw a different market. GDPR had been in effect for three years, and enforcement was accelerating. Healthcare companies couldn’t send patient data through third-party automation platforms without violating HIPAA. Financial institutions had data residency requirements that no SaaS tool could satisfy. Government contractors needed FedRAMP-compliant infrastructure.

Self-hosted wasn’t a limitation. It was the product.

The PostgreSQL backend meant data stayed in the customer’s database. The BullMQ workers ran on the customer’s servers. Workflow definitions, execution logs, credentials – everything lived behind the customer’s firewall. We just shipped the software.

June 9, 2023: The actual fork moment

Here’s something we don’t talk about often. The repository we forked in 2021 continued to track upstream Automatisch for almost two years. We pulled community improvements, contributed back where it made sense, and maintained compatibility.

That ended on June 9, 2023, when Ilia Sadykov made the commit that changed everything: “Initial internal aiwayz version of automatisch.”

That commit was the point of no return. We were no longer extending an open-source project. We were building our own product on its foundation. The repository was renamed – first to aiwayz-automatisch, then to aiwayz-autopilot. The name change wasn’t cosmetic. It signaled that we’d diverged enough that pretending otherwise was dishonest.

The divergence was technical, too. We added AI-driven actions that didn’t exist in upstream. We rewrote the execution engine to handle long-running AI tasks that could take minutes instead of milliseconds. We built proprietary integrations for services that the open-source community hadn’t prioritized.

What the fork taught us about building

Forking an open-source project is often treated as a shortcut. It’s not. It’s a trade-off.

The upside is obvious: you skip foundational work and start building product value immediately. We saved months by inheriting Automatisch’s plugin architecture, job queue, and migration system.

The downside is subtler. You inherit architectural decisions you didn’t make. Automatisch used Objection.js, which meant we were committed to that ORM even when Prisma might have been a better fit for our use case. The BullMQ worker model was elegant for short-lived tasks but required significant rework when we added AI operations that could run for minutes. The React frontend with MUI was functional but opinionated in ways that sometimes fought against what we wanted to build.

Every inherited decision is a future constraint. We spent considerable time working around architectural choices that made sense for a Zapier clone but didn’t serve an AI platform.

From 152 commits to 168 integrations

The Autopilot codebase has grown far beyond what we forked. 168 integrations spanning communication, social media, productivity, CRM, AI, and data utilities. Four webhook handler types. Three BullMQ worker types. A plugin update system that automatically refreshes model catalogs from Replicate every week.

But none of it would exist without that first fork. The decision to build on someone else’s foundation – to accept the trade-offs of inherited architecture in exchange for speed – shaped everything that came after.

We’ve since built two more products on top of the skills we developed working on Autopilot. Dashboard v1 borrowed the plugin pattern for model integrations. Dashboard v2 borrowed the worker pattern for agent execution. The fork didn’t just start a product. It started a way of thinking about how software should be assembled.

The lesson we’d pass along to anyone considering a fork: don’t fork to avoid work. Fork to redirect your work toward the problems only you can solve. The foundation is never the hard part. The hard part is what you build on top of it – and whether you’re honest about when the foundation stops serving you.

We forked Automatisch in 2021. By 2023, it wasn’t Automatisch anymore. By 2026, it’s one piece of a three-product platform. That first commit didn’t start everything. But the fork made everything possible.