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