The Visual Rule Builder is the canonical representation of FlexiRule logic — what you see is exactly what executes.
In modern enterprise systems like Frappe / ERPNext, business logic often evolves into a fragmented web of Python hooks scattered across multiple custom apps. This technical debt leads to "hook-hell," where execution order is implicit, debugging is a nightmare, and upgrades are risky.
FlexiRule changes the paradigm by providing a visual, graph-based orchestration layer. Instead of writing hidden code, you design executable business logic visually — with full control, observability, and safety.
- Centralized Logic: Move rules out of scattered
.pyfiles into a single, auditable dashboard. - No-Code Configuration: Custom UI controls (pickers, autocomplete) allow complex logic setup without a single line of code.
- Explicit Execution: Connections define deterministic paths. No more guessing which hook runs first.
- Schema-Driven UI: Configuration forms for custom logic are auto-generated from JSON schemas.
View Detailed Screenshots
Declarative, deeply nested condition trees with deterministic evaluation.
Process Operations — schema-driven configuration rendered dynamically at runtime.
FlexiRule is built around three core pillars that bridge the gap between design and execution.
A Rule defines when logic should trigger. It maps to a DocType and an event (e.g., Before Save, On Submit). It handles the initial filtering, ensuring logic only runs for the right documents and roles.
Each node in the graph is a Rule Action. It represents a specific step in your business process. Actions accept structured inputs and define the next step in the flow based on their outcome (e.g., Success → Next Step, Error → Rollback).
A Process is a file-backed module (similar to Frappe Reports/Dashboards) that acts as a container for reusable logic.
- File-Backed: Logic is stored in code (
.py) for performance and version control. - Operations: Individual functions within a process that declare their own JSON Schema for configuration parameters.
FlexiRule uses a deterministic graph-based execution engine with built-in cycle detection.
graph LR
Trigger[Rule Trigger]
--> Validate[Validate Data]
Validate -->|Valid| Dedup[Check Duplicates]
Validate -->|Invalid| Stop[Stop & Notify]
Dedup -->|Found| Block[Block Save]
Dedup -->|None| Enrich[Enrich Document]
Enrich --> Success[Finalize]
- Deterministic Graph: Zero ambiguity in execution order.
- Role-Based Security: Control which rules run for specific user roles.
- Monitoring & Logs: Full execution trace for every rule run, including input/output states and performance stats.
- Safety First: Sandboxed execution context, controlled retries, and centralized exception handling.
- Pure Terminology: Evolved from UPH → Bolton into a clean, standardized, and scalable architecture.
# Get the app
bench get-app flexirule https://github.com/Sendipad/flexirule.git
# Install to your site
bench --site [your-site] install-app flexirule
# Build assets
bench build --app flexiruleDevelopers can extend FlexiRule by creating Standard Processes:
- Create a
Processdocument and check Is Standard. - Frappe will generate
.pyand.jscontrollers in your app. - Define your logic in Python and your config UI schema in JSON.
- Your custom logic immediately appears as a selectable operation in the Visual Builder.
How to Contribute
Join the FlexiRule Community!
FlexiRule is evolving fast. Whether you are a developer, designer, or documenter, your expertise helps shape the future of visual automation in the Frappe ecosystem.
- 🐛 Bug Reports: Open an issue for any glitches.
- 💡 Feature Requests: Suggest new Nodes or Process Operations.
- 📖 Documentation: Help us clarify concepts or add examples.
- 🔧 Pull Requests: We welcome fixes, optimizations, and new features.
Follow Frappe Coding Standards and ensure all tests pass.
FlexiRule — Declarative, Visual, and Safe Business Logic for Frappe.
Built with ❤️ by the community.