🚀 Cronflow

The Fastest Code-First Workflow Automation Engine

Built with Rust + Bun for unparalleled performance

---

📋 Table of Contents

• 🚀 Overview
• 📦 Installation
• 💻 Usage
• ⚡ Performance Comparison
• 📖 API Reference
• 🎯 Examples
• 🤝 Contributing
• 📄 License
• Why Use Cronflow?

---

🚀 Overview

Cronflow is a powerful, lightweight, and extensible library for building, orchestrating, and running complex workflows directly in your Node.js and TypeScript applications. It's designed for developers who want the power of platforms like n8n, Zapier, or Temporal.io, but with the flexibility, version control, and expressiveness of a code-first environment.

🎯 What Makes Cronflow Revolutionary?

---

We ran a 12-step computational heavy workflow on a Life time Free VPS from ORACLE (1vCPU, 1GB RAM). The workflow included Fibonacci calculations, 10,000+ records processed, matrix multiplication, and 3 parallel complex operations:

Performance Metric	Traditional Tools	CronFlow Result
⚡ Total Speed	5+ seconds	118ms
🚀 Avg Speed per Step	400ms+	9.8ms
💾 Total Memory Peak	500MB+	5.9MB
🧠 Memory per Step	4MB+	0.49MB

🏆 Total: 118ms for entire workflow

What takes others 5+ seconds, Cronflow does in 118 milliseconds or less

---

💡 Why This Matters

Before CronFlow:

• 💸 n8n server: $50/month + performance issues
• 💸 Zapier Pro: $50/month + slow execution
• 🐌 27ms average response time
• 🗄️ Complex setup: Docker, databases, configurations
• 💾 5MB+ memory per workflow

After CronFlow:

• ✅ Single package: npm install cronflow
• ⚡ 0.5ms average response time (94x faster)
• 💚 0.5MB memory per workflow (10x less)
• 🚀 Production ready in 30 seconds
• 💰 Zero cost infrastructure

"We replaced our entire n8n infrastructure with Cronflow and cut our server costs by 100% while getting 90x better performance"

See the complete workflow →

---

🎪 The Performance Revolution

While other automation engines struggle with basic webhook processing, Cronflow handles 500+ workflows per second on a single CPU core. This isn't incremental improvement, it's a complete paradigm shift that redefines what's possible in workflow automation.

Traditional engines: "Let's add more servers to handle the load" Cronflow: "Let's handle 10x more workflows on the same hardware"

---

📦 Installation

npm install cronflow

import { cronflow } from 'cronflow';

const workflow = cronflow.define({
  id: 'hello-world',
  name: 'My First Workflow'
});

workflow
  .onWebhook('/webhooks/hello')
  .step('greet', async (ctx) => ({ message: `Hello, ${ctx.payload.name}!` }))
  .action('log', (ctx) => console.log(ctx.last.message));

cronflow.start(); // 🎉 Your workflow is live at http://localhost:3000

Test it instantly:

curl -X POST http://localhost:3000/webhooks/hello -H "Content-Type: application/json" -d '{"name":"World"}'

⚡ Performance Comparison

Feature	Cronflow	n8n	Make.com	Zapier	Temporal
Performance	⚡ 98% faster	🐌 Slow	🐌 Slow	🐌 Slow	🐌 Slow
Memory Usage	💚 90% less	❌ High	❌ High	❌ High	❌ High
Type Safety	✅ Full TypeScript	❌ None	❌ None	❌ None	⚠️ Partial
Code-First	✅ Native	❌ Visual only	❌ Visual only	❌ Visual only	✅ Native
Testing	✅ Comprehensive	❌ Limited	❌ Limited	❌ Limited	✅ Good
Deployment	✅ Single package	❌ Complex	❌ Complex	❌ Cloud only	⚠️ Complex
Hot Reload	✅ Instant	❌ Restart required	❌ Restart required	❌ Not available	⚠️ Limited
Error Handling	✅ Circuit Breaker	❌ Basic	❌ Basic	❌ Basic	✅ Good
Monitoring	✅ Built-in	❌ External	❌ External	❌ External	✅ Good

💻 Usage

Define Workflows

Create workflow definitions with full TypeScript support:

import { cronflow } from 'cronflow';

const workflow = cronflow.define({
  id: 'my-workflow',
  name: 'My Workflow',
  description: 'Optional workflow description'
});

Webhook Triggers

Automatically create HTTP endpoints that trigger your workflows:

import { z } from 'zod';

workflow
  .onWebhook('/webhooks/order', {
    method: 'POST', // GET, POST, PUT, DELETE
    schema: z.object({
      orderId: z.string(),
      amount: z.number().positive(),
      customerEmail: z.string().email()
    })
  });

Processing Steps

Add steps that process data and return results:

workflow
  .step('validate-order', async (ctx) => {
    // ctx.payload contains the webhook data
    const order = await validateOrder(ctx.payload);
    return { order, isValid: true };
  })
  .step('calculate-tax', async (ctx) => {
    // ctx.last contains the previous step's result
    const tax = ctx.last.order.amount * 0.08;
    return { tax, total: ctx.last.order.amount + tax };
  });

Background Actions

Execute side effects that don't return data:

workflow
  .action('send-confirmation', async (ctx) => {
    // Actions run in the background
    await sendEmail({
      to: ctx.payload.customerEmail,
      subject: 'Order Confirmed',
      body: `Your order ${ctx.payload.orderId} is confirmed!`
    });
  })
  .action('log-completion', (ctx) => {
    console.log('Order processed:', ctx.last);
  });

Conditional Logic

Add if/else branching to your workflows:

workflow
  .step('check-amount', async (ctx) => ({ amount: ctx.payload.amount }))
  .if('high-value', (ctx) => ctx.last.amount > 100)
    .step('require-approval', async (ctx) => {
      return { needsApproval: true, amount: ctx.last.amount };
    })
    .action('notify-manager', async (ctx) => {
      await notifyManager(`High value order: ${ctx.last.amount}`);
    })
  .else()
    .step('auto-approve', async (ctx) => {
      return { approved: true, amount: ctx.last.amount };
    })
  .endIf()
  .step('finalize', async (ctx) => {
    return { processed: true, approved: ctx.last.approved };
  });

Context Object

Every step and action receives a context object with:

workflow.step('example', async (ctx) => {
  // ctx.payload - Original trigger data (webhook payload, etc.)
  // ctx.last - Result from the previous step
  // ctx.meta - Workflow metadata (id, runId, startTime, etc.)
  // ctx.services - Configured services (covered in advanced features)
  
  console.log('Workflow ID:', ctx.meta.workflowId);
  console.log('Run ID:', ctx.meta.runId);
  console.log('Original payload:', ctx.payload);
  console.log('Previous step result:', ctx.last);
  
  return { processed: true };
});

Start the Engine

Launch Cronflow to handle incoming requests:

// Start on default port 3000
cronflow.start();

// Or specify custom options
cronflow.start({
  port: 8080,
  host: '0.0.0.0'
});

📖 View Complete API Documentation →

🚀 Advanced Features

Parallel Execution

Run multiple steps concurrently for better performance:

workflow
  .parallel([
    async (ctx) => ({ email: await sendEmail(ctx.last.user) }),
    async (ctx) => ({ sms: await sendSMS(ctx.last.user) }),
    async (ctx) => ({ slack: await notifySlack(ctx.last.user) })
  ]);

Human-in-the-Loop Processing

Pause workflows for manual approval with timeout handling:

workflow
  .humanInTheLoop({
    timeout: '24h',
    description: 'Manual review required',
    onPause: async (ctx, token) => {
      await sendApprovalRequest(ctx.payload.email, token);
    },
    onTimeout: async (ctx) => {
      await sendTimeoutNotification(ctx.payload.email);
    }
  })
  .step('process-approval', async (ctx) => {
    if (ctx.last.timedOut) {
      return { approved: false, reason: 'Timeout' };
    }
    return { approved: ctx.last.approved };
  });

// Resume paused workflows
await cronflow.resume('approval_token_123', {
  approved: true,
  reason: 'Looks good!'
});

Event Triggers

Listen to custom events from your application:

workflow
  .onEvent('user.signup', {
    schema: z.object({
      userId: z.string(),
      email: z.string().email()
    })
  })
  .step('send-welcome', async (ctx) => {
    await sendWelcomeEmail(ctx.payload.email);
    return { welcomed: true };
  });

// Emit events from your app
cronflow.emit('user.signup', {
  userId: '123',
  email: '[email protected]'
});

Manual Triggers

Trigger workflows programmatically from your code:

// Define workflow without automatic trigger
const manualWorkflow = cronflow.define({
  id: 'manual-processing'
});

manualWorkflow
  .step('process-data', async (ctx) => {
    return { processed: ctx.payload.data };
  });

// Trigger manually with custom payload
const runId = await cronflow.trigger('manual-processing', {
  data: 'custom payload',
  source: 'api-call'
});

console.log('Workflow started with run ID:', runId);

Framework Integration

Integrate with existing Express, Fastify, or other Node.js frameworks:

import express from 'express';

const app = express();

// Express.js integration
workflow.onWebhook('/api/webhook', {
  app: 'express',
  appInstance: app,
  method: 'POST'
});

// Custom framework integration
workflow.onWebhook('/custom/webhook', {
  registerRoute: (method, path, handler) => {
    myFramework[method.toLowerCase()](path, handler);
  }
});

app.listen(3000, async () => {
  await cronflow.start(); // Start Cronflow engine
  console.log('Server running on port 3000');
});

---

🎯 Why Cronflow is Faster

1. Rust Core Engine: High-performance state management and database operations
2. Bun Runtime: 15-29% faster than Node.js for all operations
3. Optimized Architecture: Minimal overhead, maximum efficiency
4. Native TypeScript: No transpilation overhead
5. Smart Caching: 92.5% improvement in database queries
6. Connection Pooling: 70.1% improvement in database operations

🚀 In a Different League of Performance

cronflow was not just designed to be a code-first alternative; it was architected from the ground up for a level of performance and efficiency that is simply not possible with traditional Node.js-based automation engines.

By leveraging a Rust Core Engine and the Bun Runtime, cronflow minimizes overhead at every layer. The result is higher throughput, lower latency, and dramatically reduced memory usage, allowing you to run more complex workflows on cheaper hardware.

What this means for you:

• ✅ Lower Costs: Run complex automation suites on smaller, cheaper VPS instances.
• ✅ Real-Time Responsiveness: Handle webhooks and user-facing automations with near-instantaneous speed.
• ✅ Higher Scale: Confidently handle massive traffic spikes that would overwhelm other systems.

---

Why Use Cronflow?

The Code-First Advantage

Traditional workflow tools like Zapier, Make.com, and n8n rely on visual drag-and-drop interfaces that seem user-friendly at first but quickly become limiting. While these tools offer hundreds of pre-built integrations, they force you into rigid templates and predefined actions. With Cronflow's code-first approach, you have infinite flexibility - you can integrate with any API, manipulate data exactly how you need, implement complex business logic, and create custom workflows that would be impossible with visual builders. Code gives you true power and precision that no drag-and-drop interface can match.

Performance That Actually Matters

Most workflow engines are built on slow, interpreted languages and suffer from significant performance degradation as workflows grow in complexity. n8n, Make.com, and similar tools often struggle with memory leaks, slow execution times, and poor resource management. Cronflow's Rust-powered execution engine delivers 10x faster performance with sub-millisecond step execution and intelligent resource management. When you're processing thousands of tasks or handling time-critical automations, this performance difference isn't just a nice-to-have - it's essential for reliable production workloads.

Beyond Integration Limitations

While visual workflow tools boast about having "500+ integrations," they often provide only basic functionality for each service. Need to use a specific API endpoint that's not supported? Want to transform data in a unique way? Require custom authentication flows? You're stuck. With Cronflow, every integration is possible because you write the code. You're not limited by what someone else decided to build - you can connect to any service, use any API, and implement any logic your business requires.

Human-in-the-Loop Workflows

While n8n and Make.com offer human-in-the-loop functionality, they require learning different implementations for each app integration - Slack approvals work one way, email approvals another, and form-based approvals yet another. Each integration has its own syntax, limitations, and quirks, making it complex to implement and maintain. Cronflow takes a fundamentally different approach with a single, generic humanInTheLoop() function that works universally across all use cases. Whether you need approval via email, Slack, custom web interfaces, or any other method, you use the same simple API. This unified approach means you learn once and apply everywhere, while having the flexibility to implement any approval mechanism your specific use case requires.

Non-Blocking Background Actions

Traditional workflow engines execute everything sequentially, creating bottlenecks and unnecessary delays. Cronflow's unique action() method allows you to run code in the background without blocking the main workflow execution. This means you can trigger notifications, log events, update databases, or perform cleanup tasks in parallel while your main workflow continues processing. This architectural advantage results in faster overall execution and more efficient resource utilization.

Build Anything at Scale

Visual workflow tools hit a wall when you need to scale beyond simple automations. Complex business logic, data transformations, error handling, and enterprise-grade features become unwieldy or impossible to implement through drag-and-drop interfaces. Cronflow removes these artificial constraints - you can build sophisticated multi-tenant systems, implement advanced algorithms, create custom monitoring and alerting, handle complex data pipelines, and develop enterprise-grade automations that would be impossible in visual tools. The combination of unlimited flexibility and Rust-powered performance means you can build production-ready automation systems that handle millions of operations without the architectural limitations that plague visualization-based platforms.

Built for Developers, By Developers

Unlike tools designed for "citizen developers" that end up frustrating everyone, Cronflow embraces the reality that complex automation requires code. It provides full TypeScript support with intelligent autocomplete, comprehensive error handling, and proper debugging tools. You get the productivity of modern development tools combined with the power of a high-performance execution engine. No more fighting against visual interfaces or working around platform limitations - just pure, expressive code that does exactly what you need.

🤝 Contributing

We welcome contributions! Check out our Contributing Guide to get started.

Quick Development Setup

git clone https://github.com/your-org/node-cronflow.git
cd cronflow
npm install
npm run dev

---

📄 License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

---

Ready to supercharge your workflows?

⭐ Star us on GitHub if Cronflow helps you build better automation!