MilvaionMilvaion

Distributed Job Scheduling
Built for Scale

Separate your scheduler from workers. Scale independently. Monitor everything. Milvaion is the open-source distributed job scheduling system for .NET that grows with your infrastructure.

Get StartedView on GitHub
Quick Start
# Run with Docker Compose
$ git clone https://github.com/Milvasoft/milvaion.git
$ cd milvaion
$ docker compose up -d

# Dashboard at http://localhost:5000
.NET 10PostgreSQLRedisRabbitMQ

Features

Everything You Need

A complete job scheduling platform with enterprise-grade features, built from the ground up for distributed systems.

Cron Scheduling

6-field cron expressions with second-level precision. Schedule jobs from every second to once a year.

Distributed Architecture

Separate scheduler (API) from workers. Scale each independently based on workload demands.

Reliability Built-In

Exponential backoff retries, Dead Letter Queue, zombie detection, and auto-disable for failing jobs.

Real-Time Dashboard

Beautiful UI powered by SignalR. Monitor jobs, workers, and executions in real-time.

Enterprise Management

User, role & permission management with granular access control. User activity tracking and audit logs. Built-in metric reports for job health, performance, and system diagnostics.

Multi-Channel Alerting

Google Chat, Slack, Microsoft Teams, Email, and internal notifications with configurable routing.

Graceful Shutdown

Workers complete in-progress jobs before shutting down. Offline resilience with SQLite fallback.

OpenTelemetry

Built-in Prometheus metrics, distributed tracing, and pre-configured Grafana dashboards.

Auto-Scaling

Kubernetes HPA, KEDA queue-based scaling, and concurrency policies per job type.

Built-In Workers

HTTP, SQL, Email, and Maintenance workers out of the box. No code required for common tasks.

External Schedulers

Integrate Quartz.NET or Hangfire. Keep your scheduler, add Milvaion monitoring and dashboards.

Workflow Pipelines

Chain jobs into DAG-based workflows with conditional branching, data mappings, merge nodes, and automatic orchestration.

Architecture

How Milvaion Works

A clean separation between scheduling and execution, connected by battle-tested messaging infrastructure.

Milvaion Architecture Diagram
1

Schedule

API Server

Create jobs with cron expressions via API or Dashboard. Jobs are stored in Redis ZSET sorted by next fire time.

  • Cron scheduling
  • Redis ZSET
  • Leader election
2

Dispatch

RabbitMQ

When fire time arrives, the dispatcher publishes job messages to RabbitMQ topic exchange with routing keys.

  • Topic exchange
  • Routing keys
  • Worker affinity
3

Execute

Workers

Workers consume messages, execute your IJob implementations with full DI support, and report back status.

  • IJob interface
  • DI support
  • Parallel execution
4

Monitor

Dashboard

Results flow back through RabbitMQ. Dashboard updates in real-time via SignalR. Metrics exported to Prometheus.

  • SignalR real-time
  • Prometheus metrics
  • Grafana dashboards

Built-In Workers

Zero-Code Workers

Common jobs that work out of the box. Configure through the dashboard — no code deployment needed.

HTTP Worker

Make REST API calls, send webhooks, monitor health endpoints. Supports all HTTP methods, auth types, retry policies, proxy, and mTLS.

GET / POST / PUT / DELETE / PATCH
Bearer, Basic, API Key auth
Response validation & retry
Proxy & mTLS support
{
  "method": "POST",
  "url": "https://api.example.com/notify",
  "headers": { "Authorization": "Bearer {{token}}" },
  "body": { "message": "Job completed" },
  "expectedStatusCode": 200,
  "retryCount": 3
}

SQL Worker

Execute queries across PostgreSQL, SQL Server, and MySQL. Parameterized queries, stored procedures, and transactions.

Multi-database support
Parameterized queries
Stored procedure execution
Connection alias security model
{
  "connectionAlias": "reporting-db",
  "commandType": "Text",
  "commandText": "SELECT cleanup_old_records($1)",
  "parameters": [
    { "name": "$1", "value": "30" }
  ]
}

Email Worker

Send emails via SMTP with HTML/plain text, attachments, CC/BCC, priority levels, and multiple SMTP configurations.

HTML & plain text templates
File attachments
Multiple SMTP configs
CC / BCC / Priority levels
{
  "smtpConfigName": "transactional",
  "to": ["user@example.com"],
  "subject": "Report Ready",
  "isHtml": true,
  "body": "<h1>Your report is ready</h1>",
  "priority": "High"
}

Maintenance Worker

Automated Milvaion's database maintenance, execution retention, failed execution cleanup, Redis cleanup, and archival.

Database VACUUM & ANALYZE
Execution retention policies
Failed execution cleanup
Redis key cleanup & archival
// Built-in maintenance jobs:
• DatabaseMaintenance - VACUUM, ANALYZE
• OccurrenceRetention - Delete old records
• FailedOccurrenceCleanup - Purge resolved
• RedisCleanup - Remove stale keys
• OccurrenceArchive - Archive to cold store

Workflows

DAG-Based Job Pipelines

Chain multiple jobs into directed acyclic graphs with conditional branching, data passing, and automatic orchestration.

Visual Workflow Builder

Drag-and-drop nodes, connect edges, configure steps — all from the portal UI.

Extract Prices
$.price > 100
true
Send Invoice
false
Log & Skip
Merge
Send Notification

Node Types

Task

Dispatches a scheduled job. The primary building block of every workflow.

Condition

Evaluates an expression and routes execution through true or false ports.

Merge

Waits for all incoming branches to complete before continuing downstream.

Data Mapping Example
// Step 1 (ExtractPrices) result:
{ "price": 99, "item": { "name": "Widget" } }

// Mapping on Step 2:
step1:price → amount
step1:item.name → title

// Step 2 (SendInvoice) receives:
{ "amount": 99, "title": "Widget" }

Data Mappings

Pass output fields from upstream steps into downstream job data. Schema-assisted with dot-path notation and wildcard support.

Step Delays

Add configurable delays between steps. Wait seconds after dependencies complete before dispatching.

Automatic Retries

Configure max step retries. Failed steps are retried automatically before marking as failed.

Failure Strategies

Stop on first failure or continue independent branches. Choose the right strategy per workflow.

Cron & Manual Triggers

Schedule workflows with 6-field cron expressions or trigger manually via API and portal.

Versioning & History

Every save creates a new version. Compare historical runs against the workflow definition they executed.

Dashboard

Beautiful Real-Time UI

Monitor everything from a single, responsive dashboard. Dark mode, light mode, mobile ready.

localhost:5000
Dashboard Overview

Dashboard Overview

Real-time metrics: total executions, success rate, active workers, capacity utilization, and EPM.

Comparison

Why Milvaion?

See how Milvaion compares to other popular .NET job scheduling solutions.

FeatureMilvaionHangfireQuartz.NET
ArchitectureDistributedMonolithicEmbedded
Separate Workers
Independent Scaling
Real-Time Dashboard
Built-in Workers (HTTP, SQL, Email)
Multi-Channel Alerting
OpenTelemetry / Prometheus
Grafana Dashboards
Zombie Detection
Offline Resilience
Cron PrecisionSecond-levelMinute-levelSecond-level
External Scheduler Integration
Workflows (Chaining & DAG)
Open Source

Get Started

Up and Running in Minutes

One command to start. Choose your preferred deployment method.

# Clone the repository
git clone https://github.com/Milvasoft/milvaion.git
cd milvaion

# Start all services
docker compose up -d

# Services started:
#   Milvaion API    → http://localhost:5000
#   Dashboard       → http://localhost:5000
#   PostgreSQL      → localhost:5432
#   Redis           → localhost:6379
#   RabbitMQ        → localhost:5672 (Management: 15672)
#   Seq             → http://localhost:8081
#   Grafana         → http://localhost:3000
Read Full Documentation