Modular ERP.
Modern stack. Open core.
A fully async, modular ERP built on Python and React — with an access-aware ORM and an extensibility model that doesn't fight you.
We'll notify you when we launch.
Everything you'd build yourself — already done
From CRM to eCommerce — production-ready, extensible, and open core.
Modern Stack
Async Python, FastAPI, React, PostgreSQL. Standard tools, wired together properly.
Access-Aware ORM
No SELECT *. Batch prefetch for related records. Composable Q expressions with automatic JOINs. Zero N+1.
Modular Architecture
CRM, Sales, Inventory, Accounting, eCommerce — 20+ modules included. Install what you need. Ignore the rest.
Truly Extensible
Inherit any model with __inherit__. Override computed fields and super() chains properly. No monkey-patching, no XML overrides.
Zero Migration Files
Change a field, update the module. The ORM diffs your models against the database and migrates automatically.
The stack, top to bottom
Modular by design. Built to extend.
57+ widgets, dark mode, responsive layouts. Form, calendar, virtualized list, card views and more — all rendered from YAML declarations.
Async request handling, auto-generated REST endpoints, WebSocket push, OpenAPI docs — all non-blocking.
Selective field loading, automatic prefetch, stored computed fields with dependency tracking. Writes optimized SQL so you don't have to.
Battle-tested relational database. JSONB for flexible data, full-text search, async connection pooling via asyncpg.
This is all it takes
One Python class. Fullfinity generates the database table, REST API, form view, and list view. Change a field — the schema migrates on module update.
from fullfinity.engine.base import *
class Invoice(Model):
_verbose_name = "Invoice"
customer = ManyToOne("Contact", related_name="invoices", on_delete="RESTRICT")
date = Date(default=lambda self: date.today())
state = Selection(
choices=["Draft", "Posted"],
default="Draft"
)
# Computed field — auto-updates when lines change
total = Float(calculate="calc_total", store=True)
@Model.calculate("lines", "lines__amount")
async def calc_total(self):
await self.fetch_related("lines")
self.total = sum(l.amount for l in self.lines) Define once. Get everything.
Computed fields recalculate when dependencies change and persist to the database. No signals, no manual cache invalidation, no wiring.
Stored computed fields
Declare dependencies — values auto-update across the dependency graph
Zero migration files
Change a field, update the module. The schema diffs and migrates automatically.
Python + YAML
Models in Python, views in YAML. No XML, no templates.
Composable queries. Optimized automatically.
Composable Q expressions, selective loading, automatic prefetch. Write clean Python — get optimized queries.
from fullfinity.engine.base import *
# Compose filters with & (AND) and | (OR)
Invoice = get_model("Invoice")
invoices = await Invoice.filter(
Q(state="Posted")
& Q(date__lte=today)
& Q(total__gt=1000)
).all()
# Nested lookups across relationships
JournalEntryLine = get_model("JournalEntryLine")
results = await JournalEntryLine.filter(
Q(entry__state="Posted")
& Q(account__type="Receivable")
& Q(entry__date__lte=cutoff)
).all()
# Complex nested: overdue invoices OR high-value drafts
urgent = await Invoice.filter(
(Q(state="Posted") & Q(due_date__lt=today))
| (Q(state="Draft") & Q(total__gt=10000))
).order_by("due_date ASC").all() Q expressions
Build complex queries with composable filter objects. Chain conditions with & and | operators. Traverse relationships with double-underscore lookups — the ORM generates efficient JOINs automatically. The same Q syntax works everywhere: Python code, YAML views, even widget filters.
__eq __neq Equality and inequality (__eq is the default)
__gt __gte __lt __lte Comparison operators for numbers, dates, and more
__in __nin Match or exclude against a list of values
__contains __icontains Substring search, case-sensitive or insensitive
__startswith __endswith Prefix and suffix matching
__isnull __isnotnull NULL checks for optional fields
field__rel Traverse relationships — generates JOINs, not extra queries
Fast by default
Every query targets specific columns, not SELECT *. Prefetch related records in batches to cut round trips.
Selective field loading
Loads only the columns your code touches — not SELECT *
Automatic prefetch
Related records batch-loaded in minimal queries — N+1 eliminated
Stored computed fields
Dependencies declared once — values cascade automatically on change
# Prefetch related records in one query
SaleOrder = get_model("SaleOrder")
orders = await SaleOrder.filter(
state="Confirmed"
).prefetch_related(
"customer", "lines", "lines__product"
).all()
# 3 queries total, not 1 + N + N*M
for order in orders:
print(order.customer.name)
for line in order.lines:
print(line.product.name)
# Stored computed field with dependencies
total = Float(calculate="calc_total", store=True)
@Model.calculate("lines", "lines__quantity", "lines__price")
async def calc_total(self):
await self.fetch_related("lines")
self.total = sum(
l.quantity * l.price for l in self.lines
)
# When any line's quantity or price changes,
# total auto-recomputes and saves to DB 59+ widgets. Zero frontend code.
Badge, DatePicker, BarChart, Kanban — declare what you need in YAML. The React frontend handles rendering, dark mode, and responsiveness.
Input
25Display
14Charts
5Select
7Dashboard
3Views
5- type: field
name: status
properties:
widget: Badge
colors:
Draft: gray
Posted: green
Cancelled: red
- type: field
name: customer
properties:
widget: AvatarCombo
filter: Q(is_customer=True)
- type: field
name: monthly_data
properties:
widget: BarChart
dataKey: month
h: 150 Modules & Roadmap
22 modules ready at launch. More on the way. Install what you need, skip what you don't.
Commercial
Leads, pipeline stages, activity tracking
Quotes, orders, margin analysis
RFQs, vendor bills, reorder rules
Multi-currency, credit notes, payment matching
Double-entry, bank reconciliation, tax reports
Storefront, cart, reviews, wishlists
Touch interface, receipts, cash management
Operations
Routes, lot traceability, reservations
BOMs, work orders, capacity scheduling
Engineering changes and version control
Productivity
Tasks, Kanban boards, time tracking
Calendar events and scheduling
Custom dashboards and reports
Employee records and org chart
Salary computation and payslips
Tickets, SLAs, knowledge base
Tools
Drag-and-drop pages, themes, SEO
Posts, categories, comments
Self-service document access
Custom models and views, no code
Multi-step request workflows
Marketing
Campaigns, templates, tracking
Registration, tickets, scheduling
Forms, responses, data collection
Multi-platform content scheduling
AI
Scan bills and invoices, pre-fill forms
Search records using plain English
Predictive replenishment optimization
Explain records, summarize history, surface insights
Integrations
Cards, subscriptions, webhooks
Express checkout and refunds
UPI, cards, net banking
iDEAL, Bancontact, EU cards
POS and online payments
Two-way event sync
+ 10 country localizations (US, UK, IN, DE, FR, AU, CA, BR, AE, SG)
Why Fullfinity?
We spent years customizing ERPs — fighting slow ORMs, brittle view inheritance, and upgrade paths that didn't exist. So we built the platform we wished we'd had.
| Feature | Fullfinity | Odoo | ERPNext |
|---|---|---|---|
| Concurrency | Async — thousands of concurrent connections | Multi-process (pre-fork workers) | Multi-process (Gunicorn workers) |
| ORM | Selective field loading, auto-prefetch, zero N+1 | Lazy loading — extra queries per field group | Basic DocType ORM |
| Frontend | React | OWL (proprietary) | Frappe UI (proprietary) |
| Views | YAML — clean, readable | XML with XPath | JSON (DocType) |
| Version upgrades | Built-in, free for all users | Enterprise only (paid) | bench update + manual patches |
| Computed fields | Stored, with automatic dependency cascades | Recomputed on read (not stored by default) | Virtual only (no stored compute) |
| Caching | Distributed query cache with auto-invalidation | In-memory (per-worker) | Redis (manual) |
| API | Auto-generated REST + OpenAPI docs | JSON-RPC | REST (Frappe API) |
| License | Community (LGPL) + Enterprise add-ons | LGPL (Community) / Proprietary (Enterprise) | GPLv3 |
| Ecosystem | New — growing community | Massive — 50K+ apps, large partner network | Active open-source community |
Ready for a modern ERP?
Join the waitlist and be the first to know when we launch.
No spam. Unsubscribe anytime.