thinkNXG Framework — Build Business Apps Fast

Full-Stack · FLOSS · Python & JavaScript

Build business apps
10× faster with thinkNXG

thinkNXG Framework is a batteries-included, full-stack web development platform. Metadata-driven, low-code architecture for building powerful business applications without reinventing the wheel.

Get Started Explore Features

Python

JavaScript

MariaDB

Redis

Docker

MIT License

10.2K GitHub Stars

10.2^K

GitHub Stars

22^K+

Community Members

700⁺

DocTypes in ERPNext

97^%

Dev Effort Eliminated

2005

Year Founded

Why thinkNXG Framework

Stop rebuilding the same app over and over

Most software development is about capturing structured data, processing it, and showing reports and dashboards. Yet we spend an enormous amount of time building these same patterns again and again — choosing a front-end, wiring up a back-end, managing migrations.

thinkNXG Framework eliminates that repetition. Like a Swiss Army knife, it comes packed with everything you'll need: a powerful admin UI, baked-in roles and permissions, automatic REST APIs, background job handling, and a metadata-driven ORM that propagates changes everywhere — instantly.

Convention over Configuration over CodeStandardized building blocks mean you focus on business logic, not boilerplate.

Metadata drives everythingChange a field in the UI and the database schema, form, and API update automatically.

Built for real enterprise scaleERPNext, with 700+ object types, runs on the same framework — proven at massive scale.

customer.py

# Define a DocType — the basic building block
# Schema + Form + API generated automatically
import frappe
from frappe.model.document import Document

class Customer(Document):

    def before_save(self):
        # Custom logic hook — runs before every save
        self.full_name = f"{self.first_name} {self.last_name}"
def after_insert(self):
        # Send welcome email automatically
        frappe.sendmail(
            recipients=self.email,
            subject="Welcome to thinkNXG",
            template="welcome_customer"
        )

# Instantly available as REST API:
# GET  /api/resource/Customer
# POST /api/resource/Customer
# GET  /api/resource/Customer/{name}

DocType

The fundamental building block of every app

All complex systems are built from simple primitives. In thinkNXG Framework, that primitive is a DocType — the model, view, and controller for your application, all in one.

A DocType doesn't just manage your database schema — it also stores metadata about how your data behaves. Since metadata lives in a database table too, you can change the schema and UI on the fly, without redeployment or migrations.

Schema + UI in syncAdd a field in the form builder and it's in the database and API immediately.

Built-in ORMWork with Python objects instead of SQL — no more query debugging.

Virtual DocTypeConnect external data sources and get a full CRUD UI without the coding chaos.

Granular permissionsSet read, write, create, delete, export, and print permissions per role, per DocType.

Sales Order DocType ● Draft

Customer

Acme Corp

Order Date

10-Jun-2026

Delivery Date

20-Jun-2026

Currency

INR ₹

Grand Total

₹ 1,24,500

Sales Person

Rahul Sharma

Items (3)

Laptop Pro X1₹ 80,000

Wireless Mouse₹ 2,500

USB-C Hub (×2)₹ 6,000

Web Framework

Everything you need to ship fast

Building from scratch involves designing databases, creating UIs, and managing background tasks. thinkNXG Framework bundles a CMS, router, ORM, and background job queue so you can skip the plumbing.

Content Management System

A built-in CMS handles dynamic rendering, templating, and rich text editing — all under one roof. No third-party CMS to integrate or maintain.

File-based Routing

Create a web page file and routing is handled automatically. No manual setup, no route configuration — just a more efficient way to build pages.

Background Jobs

Redis-powered background job handling keeps your app responsive. Offload long-running tasks, schedule processes, and manage queues without slowing users down.

Built-in ORM

thinkNXG's ORM converts database tables into Python classes. Interact with data as objects — no raw SQL, no migration headaches, less debugging time.

Real-time with WebSockets

Live updates for forms, dashboards, and notifications via WebSockets. Users see changes as they happen — no polling, no page refreshes.

Multi-site Architecture

A single instance can serve multiple tenants, each with its own database and config, sharing the same codebase. Ideal for SaaS deployments at any scale.

Desk UI

A complete admin interface — no code required

thinkNXG Framework ships with a pre-built, permission-controlled admin interface called Desk. Forms, list views, tree views, Kanban boards, calendars, and dashboards — all ready to use and fully customizable without writing a line of frontend code.

Form BuilderDrag-and-drop form design with all field types: data, select, check, rating, attachment, and more. Add conditions, mandatory rules, and field visibility logic visually.

Configurable WorkspaceCustomize the home workspace to show the most-used DocTypes, reports, and charts. Monitor everything at a glance when you log in.

Powerful Report BuilderBuild grid reports with charts and dashboards using DocType-based configuration, SQL queries, or Python scripts — no BI tool needed.

List View

Filterable, sortable table of all records. Bulk actions, custom columns, and saved filters built in.

Calendar

Date-based views for tasks, events, or any DocType with a date field. Drag to reschedule.

Kanban Board

Drag-and-drop Kanban organized by any select field. Filter by user, priority, or custom fields.

Tree View

Hierarchical views for departments, ledgers, or any parent-child relationship in your data.

Dashboard & Reports

Charts, KPI cards, and configurable dashboards. Write grid reports using DocType config, SQL, or Python — no external BI tool.

API & Integrations

Every DocType is an API — automatically

When you create a DocType, CRUD REST APIs are generated for it automatically. No need to write endpoint handlers or serializers. Connect your app to anything without custom integration code.

Auto-generated REST APIsFull CRUD endpoints for every DocType: GET, POST, PUT, DELETE — all secured by your role-permission config.

Custom RPC EndpointsWrite a Python function, decorate it with @frappe.whitelist(), and it's instantly accessible as an API endpoint.

OAuth 2.0 ProviderthinkNXG Framework can act as an OAuth provider — single sign-on across all your apps with token-based or password-based auth.

Webhooks & EventsTrigger external systems on any document event — on_submit, on_cancel, after_insert — with configurable webhooks.

api.py — custom endpoint

# Auto-generated CRUD — no code needed
# GET  /api/resource/Customer
# POST /api/resource/Customer
# Custom RPC endpoint — just add @whitelist
@frappe.whitelist()
def get_customer_summary(customer_name):
    customer = frappe.get_doc("Customer", customer_name)
    orders   = frappe.get_list(
        "Sales Order",
        filters={"customer": customer_name},
        fields=["name", "grand_total"]
    )
    return {
        "customer": customer.customer_name,
        "total_orders": len(orders),
        "lifetime_value": sum(o.grand_total for o in orders)
    }

# Accessible at:
# /api/method/myapp.api.get_customer_summary
# ?customer_name=Acme+Corp

Users & Permissions

Fine-grained access control out of the box

For every DocType, set precise role-based permissions defining who can read, write, create, delete, export, or print. Give each team member exactly the access they need — no more, no less.

Role	Read	Write	Create	Delete	Submit	Export	Print
System Manager
Sales Manager
Sales User
Auditor
Customer (Portal)

Backed by the Best

Apps built with thinkNXG Framework

Complex business solutions — ERPNext, Helpdesk, Insights, Builder — all run on the same foundation. A consistent, robust platform for whatever you need to build.

thinkNXG ERP

thinkNXG HR

thinkNXG CRM

Helpdesk

Insights

Builder

Learning LMS

Drive

User Reviews

Trusted by developers worldwide

thinkNXG Framework provides hundreds of out-of-the-box components — from seamless UI to accounting to lead management to permissions to workflows — absolutely everything imaginable. One does not have to re-invent yet another CRUD back-office system. 97.42% of development effort is eliminated.

Kailash Nadh

CTO at Zerodha

The metadata-driven approach is what sets it apart. You define your data model once, and the forms, APIs, reports, and permissions all follow automatically. Building enterprise applications has never been this efficient — we shipped our entire platform in weeks, not months.

Arjun Rao

Founder, BuildStack

Origins

A framework inspired by the Semantic Web

Started in 2005, thinkNXG Framework was inspired by the Semantic Web — the idea that software should describe not just how information is displayed (like headings and body text), but what it means (like name, address, date).

By building a web framework that allows easy definition of metadata, it made constructing complex applications straightforward. Applications designed around the semantics of the underlying system are far more consistent and extensible than those designed only around user interaction.

The first application built on Framework was ERPNext, a system with more than 700 object types. Framework is not for beginners — it is for developers ready to do real work at real scale.

Framework Timeline

2005 — The Beginning

Framework born, inspired by Semantic Web principles.

2010 — ERPNext Launched

First major application with 700+ DocTypes built on Framework.

2018 — FLOSSd

MIT license, community of 22K+ developers worldwide.

2024–26 — thinkNXG Era

Rebranded distribution for the next generation of FLOSS business software.

Got a Query?

Frequently asked questions

What makes thinkNXG Framework different from Django or Laravel?

thinkNXG Framework is a full-stack, batteries-included platform designed specifically for business applications. Unlike Django or Laravel, which give you a foundation to build from, Framework provides a metadata-driven ORM, automatic REST API generation, role-based permissions, form and list views, real-time updates, workflows, and reports — all out of the box. You focus on business logic, not infrastructure.

Does it support responsive web applications out of the box?

Yes. Framework's UI components — forms, reports, dashboards, Kanban boards — are mobile-friendly by default. The Desk interface supports SPA-like interactions, and all views are designed to work across screen sizes without custom CSS.

What database and hosting options are supported?

thinkNXG Framework uses MariaDB/MySQL as its primary database, with Redis for caching and background job queues. Applications can be hosted on any Linux server using Docker containers, or deployed on thinkNXG Cloud for managed hosting with zero setup.

Can I build multi-tenant SaaS applications with it?

Absolutely. Multi-tenancy is a core feature. A single Framework instance can serve multiple sites (tenants), each with its own database and configurations, while sharing the same codebase. This makes it ideal for SaaS deployments where each customer gets a logically isolated environment.

How extensible is it for custom business logic?

Highly extensible. Add custom apps, define your own schemas, write client-side scripts, and hook into server-side events with Python. The modular architecture lets you extend existing apps or build entirely new ones while keeping your business logic separate and maintainable. You can even override predefined document methods.

Customisation, Low Code, Deployment & Dashboards →

Chat us

Build business apps10× faster with thinkNXG