Enterprise-Grade • Production-Ready
Open Source Rule Engine

Build Complex Business Logic Horizontally Scalable Immutable & Versioned Sub-microsecond Fast Visually Configured AI-Powered

A high-performance, domain-agnostic rule engine with visual configuration, AI-powered assistance, and sub-microsecond evaluation. Clone products, experiment safely with immutable versioning, and scale horizontally with DGraph persistence.

Rust Rust Backend React React 19 TypeScript TypeScript GraphQL + gRPC
Product-FARM Dashboard
Build Passing
Backend Tests 234
E2E Suites 9
Coverage 85%
Performance <1ms
License Apache 2.0
~330ns
Rule Evaluation (Bytecode)
3M+
Evals/sec (Single Thread)
22M+
Evals/sec (Parallel)
85%
Test Coverage
234+
Backend Tests
3.5x
Bytecode Speedup
10K+
Rules per Product
DGraph
Graph Persistence

What Makes Product-FARM Unique

Enterprise-grade features designed for scalability, reliability, and developer experience

🔄

Immutable Product Versioning

Products remain immutable. Clone to experiment, roll back instantly. Full audit trail of every change with complete traceability.

Version Control Audit Trail Instant Rollback
📋

Powerful Template Cloning

Clone entire products with deep copy. Introduce new features, rule changes, functionality additions while keeping originals intact.

Deep Clone Selective Copy DoS Protection
📈

Horizontally Scalable

Built on DGraph graph database. Distributed by design. Scale to millions of rules and evaluations with strong durability.

Graph Database Distributed Backup Support
⚡

Intelligent Caching

LRU cache for frequently evaluated rules. Configurable sizes: Products (100), Attributes (10K), Rules (10K), Compiled (10K).

Write-Through Bounded Memory Hot Path Opt
🔒

Fine-Grained Access Control

Control at component and template level. Give required control to required people. Ownership boundaries respected throughout.

Component RBAC Approval Flow Audit Logging
🏗

Microservice-Ready

Engine owns product integrity and logic. Functionalities served by respective microservices. Clean separation of concerns.

Separation API Integration Service Ownership
🚀

Tiered Compilation Engine

AST interpretation for initial runs, bytecode compilation for hot paths. 3.5x speedup from 1.15µs to 330ns per evaluation.

Auto-Optimize 3.5x Speedup Bytecode VM
🌐

DAG-Based Parallelism

Rules form a directed acyclic graph. Independent rules execute in parallel. Automatic dependency resolution and cycle detection.

Parallel Exec Cycle Detection Level Scheduling
🎨

No-Code Visual Builder

Build complex business logic with drag-and-drop. Real-time validation, instant feedback, no coding required. JSON Logic under the hood.

Drag & Drop Real-Time Valid JSON Logic
🤖

AI-Powered Configuration

Create rules from natural language. AI explains complex logic, suggests optimizations, helps debug issues. Your intelligent assistant.

Natural Language Rule Explain Debug Assist
🔌

REST + gRPC APIs

REST API for management operations, gRPC for high-performance evaluation. Stream processing for real-time data pipelines.

REST Mgmt gRPC Eval Streaming
🗄

DGraph Persistence

Purpose-built for complex relationships. Native graph queries, strong durability, configurable backups. Data integrity guaranteed.

Graph Native Strong Durability Backup Support

Domain-Agnostic by Design

Power complex business logic across any industry with a flexible, extensible rule engine

🏦

Insurance

Premium calculations, risk assessment, underwriting rules, and claims processing

💰

Financial Services

Loan eligibility, trading signals, credit scoring, and fraud detection

🛒

E-commerce

Dynamic pricing, inventory rules, promotions, and recommendation engines

🏥

Healthcare

Risk scoring, eligibility checks, care protocols, and compliance rules

🏭

Manufacturing

Quality control, process automation, compliance, and supply chain rules

🚚

Logistics

Shipping calculations, route optimization, capacity planning, and SLA rules

How It Works

From product definition to rule evaluation in five simple steps

1 📦
Define Product
Create your product structure
2 📝
Create Attributes
Define inputs, outputs, and types
3 🔧
Write Rules
Build logic visually or via API
4 🌐
Build DAG
Auto dependency resolution
5 ⚡
Evaluate
Sub-microsecond execution
🖥
Frontend
React 19 + TypeScript
→
🔌
API Layer
REST + gRPC
→
⚙
Rule Engine
Rust + Bytecode VM
→
🗄
Storage
DGraph + LRU Cache

Your Intelligent Rule Assistant

Create, explain, and optimize rules using natural language. The AI understands your business logic.

💬 Natural Language Rule Creation

Describe your rules in plain English. The AI translates them into optimized JSON Logic expressions.

"Create a rule: if age > 60, add 20% to premium"
↓
AI generates the complete rule with inputs, outputs, and JSON Logic expression
AI Rule Generation
🧠

Explain Rules & DAG

Don't understand a complex rule? Ask AI to explain it in plain language, including dependencies.

🔍

Impact Analysis

Before changes, understand ripple effects. AI shows which rules and attributes will be affected.

🚀

Optimization Hints

Get intelligent recommendations to improve rules, find redundancies, and boost performance.

✨

Quick Actions

One-click access: Create Rule, Explain Rule, Optimize, and Impact Analysis buttons always ready.

Simple Yet Powerful

JSON Logic expressions make complex business rules readable and maintainable

premium_calculation.json
{
  "rule_type": "CALCULATION",
  "display_expression": "final_premium = base_premium * age_factor * smoker_factor",
  "expression": {
    "*": [
      {"var": "base_premium"},
      {"var": "age_factor"},
      {"var": "smoker_factor"}
    ]
  },
  "inputs": ["base_premium", "age_factor", "smoker_factor"],
  "outputs": ["final_premium"]
}

Ready to Transform Your Business Logic?

Get started with Product-FARM in under 5 minutes. Open source, free forever.

Read the Quick Start Guide