Pre-launch — Join the waitlist

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.

app.fullfinity.com
Fullfinity ERP

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.

Frontend React

57+ widgets, dark mode, responsive layouts. Form, calendar, virtualized list, card views and more — all rendered from YAML declarations.

API FastAPI

Async request handling, auto-generated REST endpoints, WebSocket push, OpenAPI docs — all non-blocking.

ORM Access-Aware Engine

Selective field loading, automatic prefetch, stored computed fields with dependency tracking. Writes optimized SQL so you don't have to.

Database PostgreSQL

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.

models/invoice.py
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.

Q expressions
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

smart loading
# 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

25
TextInput NumberInput RichTextEditor DatePicker ColorInput FileUpload PinInput Slider

Display

14
Badge Avatar Progress Rating Image StatusBar Icon Tags

Charts

5
Sparkline BarChart AreaChart RadarChart Pivot

Select

7
DataCombo MultiCombo AvatarCombo Radio RadioCards SegmentedControl SelectCombo

Dashboard

3
Card CompactList LinkedRecords

Views

5
List Kanban Calendar Gantt Form
views/invoice_views.yaml
- 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.

Available
Planned

Commercial

CRM

Leads, pipeline stages, activity tracking

Sales

Quotes, orders, margin analysis

Purchase

RFQs, vendor bills, reorder rules

Invoicing

Multi-currency, credit notes, payment matching

Accounting

Double-entry, bank reconciliation, tax reports

eCommerce

Storefront, cart, reviews, wishlists

Point of Sale

Touch interface, receipts, cash management

Planned

Operations

Inventory

Routes, lot traceability, reservations

Manufacturing

BOMs, work orders, capacity scheduling

PLM

Engineering changes and version control

Planned

Productivity

Projects

Tasks, Kanban boards, time tracking

Meetings

Calendar events and scheduling

BI Dashboard

Custom dashboards and reports

People

Employee records and org chart

Planned
Payroll

Salary computation and payslips

Planned
Helpdesk

Tickets, SLAs, knowledge base

Planned

Tools

Website Builder

Drag-and-drop pages, themes, SEO

Blog

Posts, categories, comments

Client Portal

Self-service document access

App Builder

Custom models and views, no code

Approvals

Multi-step request workflows

Marketing

Email Marketing

Campaigns, templates, tracking

Planned
Events

Registration, tickets, scheduling

Planned
Surveys

Forms, responses, data collection

Planned
Social Media

Multi-platform content scheduling

Planned

AI

Document Extraction

Scan bills and invoices, pre-fill forms

Planned
Natural Language Search

Search records using plain English

Planned
Demand Forecasting

Predictive replenishment optimization

Planned
Copilot

Explain records, summarize history, surface insights

Planned

Integrations

Stripe

Cards, subscriptions, webhooks

PayPal

Express checkout and refunds

Razorpay

UPI, cards, net banking

Mollie

iDEAL, Bancontact, EU cards

Square

POS and online payments

Google Calendar

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
10x
fewer queries
vs traditional ORMs
10K+
concurrent connections
non-blocking I/O
57+
UI widgets
zero frontend code
<50ms
avg response time
database to browser

Ready for a modern ERP?

Join the waitlist and be the first to know when we launch.

No spam. Unsubscribe anytime.