GitHub - ngbplatform/NGB: Open-source .NET + PostgreSQL foundation for document-driven business apps with registers, audit, reporting, and accounting.

NGB Platform

Open-source .NET + PostgreSQL platform for document-driven business applications.

Built for modular business systems with catalogs, documents, lifecycle actions, operational and reference registers, audit history, reporting, metadata-driven UI, and optional accounting.

Website · Docs · Property Management (Live Demo) · Trade (Live Demo) · Agency Billing (Live Demo)

NGB Platform Intro

▶️ Watch the intro video on YouTube

What is NGB Platform
Why NGB exists
Who NGB is for
What you can build with NGB
Core capabilities
Live demos
Architecture overview
Architecture flow
Monorepo structure
Technology stack
Performance testing
Getting started
Design principles
Contributing
License

What is NGB Platform

NGB Platform is an open-source platform for building document-driven business applications and industry-specific vertical solutions on .NET and PostgreSQL

NGB provides a production-oriented foundation for systems built around:

catalogs and business documents;
posting and accounting effects;
operational and reference registers;
metadata-driven forms and lists;
auditability and explainability;
reporting and analytical views;
vertical solutions built on a shared platform core.

NGB is not a low-code toy and not a monolithic ERP bundle. It is a platform for building serious line-of-business systems with a clear architecture, strong domain conventions, and a practical path from framework to real vertical applications.

Why NGB exists

Business software is usually forced into one of two extremes:

generic web frameworks, which are flexible but leave the hardest business architecture problems unsolved;
large ERP products, which are powerful but heavy, inflexible, and difficult to adapt cleanly.

NGB exists to offer a third path:

a modular platform instead of one-off project scaffolding;
a business-application architecture instead of generic MVC plumbing;
a document-driven business foundation instead of ad-hoc CRUD screens and one-off workflow logic;
accounting capabilities when a vertical needs financial posting and reporting;
a shared platform core + vertical solutions model instead of duplicating infrastructure across products.

The goal is simple: help developers and product teams build production-grade business systems faster, with fewer architectural compromises and a stronger long-term foundation.

Who NGB is for

NGB is designed for:

software engineers and architects building serious business applications;
product teams creating vertical SaaS or internal business platforms;
consultancies and implementation teams building industry-specific solutions;
founders who need a reusable platform for multiple business products;
teams that want source code ownership instead of vendor lock-in.

NGB is especially relevant when your solution includes one or more of the following:

business documents with lifecycle and posting;
accounting logic or financial statements;
operational balances or register-style state tracking;
metadata-driven UI and dynamic forms;
auditable history and explainable system behavior;
multiple industry solutions sharing one platform base.

What you can build with NGB

NGB is designed for building serious business software.

It is well suited for applications where business documents, workflows, accounting, reporting, auditability, and domain-specific rules are core architectural concerns rather than secondary features.

With NGB, teams can build:

vertical business applications;
finance and operations platforms;
accounting-enabled SaaS products;
internal enterprise systems;
industry-specific ERP-style solutions;
workflow-heavy back-office applications;
custom business platforms with strong domain modeling;
long-lived systems that require explainability, consistency, and extensibility.

The demo solutions included in this repository show a few possible applications of the platform, but they do not limit the range of systems that can be built with NGB.

Core capabilities

Platform foundation

Modular architecture built for shared platform capabilities and vertical extensions.
Clear separation between core domain, runtime, infrastructure, application hosts, and industry solutions.

Business application model

Metadata-driven catalogs and documents.
Universal patterns for lists, forms, payloads, actions, and UI metadata.
Consistent lifecycle model for business objects and business documents.

Accounting and register engine

Production-oriented accounting foundation.
Operational registers and reference registers as first-class platform concepts.
Append-only business history and effect-oriented modeling.
Support for posting flows, balances, turnovers, and financial reporting.

Reporting and analysis

Platform reporting contracts and execution model.
Interactive reporting surface for business and accounting scenarios.
Report definitions, filters, grouping, exports, and vertical reports.

Operations and platform services

PostgreSQL as the system of record.
Background jobs infrastructure.
Database migration tooling.
Watchdog / health surface.
Structured observability hooks.
SSO integration through Keycloak.

Frontend and UX foundation

Shared UI framework.
Metadata-driven web applications for vertical solutions.
Custom branding and authentication theme support.

Live demos

🔑 Demo access

The demo applications include a preconfigured administrator account for evaluation purposes.

Default demo user

Name: Alex Carter
Role: Admin
Email: alex.carter@demo.ngbplatform.com
Password: DemoAdmin!2026

This account is intended for demo and evaluation use only.

Explore NGB through live demo solutions

Property Management — https://pm-demo.ngbplatform.com
Trade — https://trade-demo.ngbplatform.com
Agency Billing — https://ab-demo.ngbplatform.com

The repository currently contains the platform core and source code for the demo solutions in this monorepo. Live demos are intended to show how one platform can support multiple business domains with a shared architectural base.

Architecture overview

NGB follows a layered platform architecture built around reusable platform hosts, shared contracts and metadata, a central execution core, specialized business engines, and PostgreSQL-based persistence.

At the top level, NGB provides dedicated platform hosts for API delivery, background processing, health and operability, and schema deployment. These hosts do not implement business behavior themselves. Instead, they compose and expose the platform through shared contracts, abstractions, and runtime orchestration.

At the center of the platform is NGB.Runtime. It acts as the execution core that coordinates catalogs, documents, posting, reporting, validation, and workflow behavior. Rather than scattering business logic across hosts, NGB concentrates orchestration in the runtime layer and delegates specialized responsibilities to dedicated platform engines.

Those engines include NGB.Accounting, NGB.OperationalRegisters, NGB.ReferenceRegisters, and the business audit log. Together they provide the core business mechanics of the platform: ledger semantics, register-based state handling, reference-state projection, and append-only auditability.

Persistence and database interaction are handled through NGB.PostgreSql, which serves as the platform’s infrastructure bridge for readers, writers, and migration support. Platform data is stored in PostgreSQL, while authentication is integrated with Keycloak.

High-level architecture

flowchart TB
    classDef host fill:#fff4e5,stroke:#c77d1a,stroke-width:1.5px,color:#111827;
    classDef surface fill:#eef4ff,stroke:#2f5fb3,stroke-width:1.5px,color:#111827;
    classDef runtime fill:#eafaf1,stroke:#1f8f57,stroke-width:1.8px,color:#111827;
    classDef engine fill:#f3ecff,stroke:#7c3aed,stroke-width:1.5px,color:#111827;
    classDef infra fill:#f7f7f7,stroke:#6b7280,stroke-width:1.5px,color:#111827;
    classDef external fill:#ffffff,stroke:#9ca3af,stroke-width:1.2px,color:#111827;

    subgraph HOSTS["Platform Hosts"]
        API["NGB.Api<br/>HTTP / API host"]
        BG["NGB.BackgroundJobs<br/>Scheduled job host"]
        WD["NGB.Watchdog<br/>Health / operability host"]
        MIG["NGB.Migrator<br/>Schema deployment host"]
    end

    subgraph SURFACE["Contracts, Metadata, and Platform Surface"]
        CONTRACTS["NGB.Contracts<br/>Public DTOs and API contracts"]
        APPABS["NGB.Application.Abstractions<br/>Application-facing interfaces"]
        DEFINITIONS["NGB.Definitions<br/>Catalogs, documents, reports, behaviors"]
        METADATA["NGB.Metadata<br/>Metadata model and descriptors"]
        CORE["NGB.Core<br/>Common primitives and shared foundation"]
    end

    subgraph EXECUTION["Execution Core"]
        RUNTIME["NGB.Runtime<br/>Orchestration of catalogs, documents,<br/>posting, reporting, validation, and workflow"]
    end

    subgraph ENGINES["Business Engines"]
        ACCOUNTING["NGB.Accounting<br/>Ledger and posting semantics"]
        OR["NGB.OperationalRegisters<br/>Operational register engine"]
        RR["NGB.ReferenceRegisters<br/>Reference register engine"]
        AUDIT["Business AuditLog<br/>Append-only audit trail"]
    end

    subgraph INFRA["Persistence and Integration"]
        PG["NGB.PostgreSql<br/>Persistence, readers, writers, migrations support"]
    end

    subgraph EXTERNAL["External Systems"]
        DB[("PostgreSQL")]
        KC["Keycloak"]
    end

    API --> CONTRACTS
    API --> APPABS
    BG --> APPABS
    WD --> APPABS
    MIG --> PG

    CONTRACTS --> RUNTIME
    APPABS --> RUNTIME
    DEFINITIONS --> RUNTIME
    METADATA --> RUNTIME
    CORE --> RUNTIME

    RUNTIME --> ACCOUNTING
    RUNTIME --> OR
    RUNTIME --> RR
    RUNTIME --> AUDIT
    RUNTIME --> PG

    ACCOUNTING --> PG
    OR --> PG
    RR --> PG
    AUDIT --> PG

    API -. authentication .-> KC
    BG -. authentication .-> KC
    WD -. authentication .-> KC

    PG --> DB

    class API,BG,WD,MIG host;
    class CONTRACTS,APPABS,DEFINITIONS,METADATA,CORE surface;
    class RUNTIME runtime;
    class ACCOUNTING,OR,RR,AUDIT engine;
    class PG infra;
    class DB,KC external;

Architectural layers

Platform Hosts
Entry-point hosts for HTTP APIs, background jobs, health monitoring, and schema deployment.
Contracts, Metadata, and Platform Surface
Shared DTOs, application abstractions, metadata, definitions, and common primitives that define how the platform is described and consumed.
Execution Core
The central orchestration layer implemented by NGB.Runtime.
Business Engines
Specialized engines for accounting, operational registers, reference registers, and append-only audit logging.
Persistence and Integration
PostgreSQL-based infrastructure through NGB.PostgreSql, plus integration with external systems such as PostgreSQL and Keycloak.

Architecture flow

The following diagram shows the typical business flow through NGB.

sequenceDiagram
    participant User as User
    participant Web as Vertical Web App
    participant Api as Vertical API Host
    participant Rt as NGB Runtime
    participant Def as Definitions / Metadata
    participant Acc as Accounting / Registers
    participant Pg as PostgreSQL
    participant Rpt as Reporting

    User->>Web: Create or edit business document
    Web->>Api: Submit document payload + action
    Api->>Rt: Execute platform document flow
    Rt->>Def: Resolve metadata, rules, actions, UI behavior
    Rt->>Pg: Persist business document state
    Rt->>Acc: Produce posting and business effects when applicable
    Acc->>Pg: Append accounting, operational, and reference effects
    Pg-->>Rt: Commit durable business state
    Rt-->>Api: Return document, status, metadata, effects
    Api-->>Web: Return UI-ready response
    Web-->>User: Render document and actions

    User->>Web: Run operational or financial report
    Web->>Api: Execute report
    Api->>Rt: Resolve report definition and execution plan
    Rt->>Rpt: Build dataset, grouping, layout, and interactions
    Rpt->>Pg: Read source data and aggregates
    Pg-->>Rpt: Return result set
    Rpt-->>Api: Return report sheet + interactive targets
    Api-->>Web: Return report response
    Web-->>User: Render report, drilldowns, exports, navigation

Monorepo structure

This repository is organized as a single monorepo.

NGB.sln
│
├─ Platform core
│  ├─ NGB.Core
│  ├─ NGB.Metadata
│  ├─ NGB.Definitions
│  ├─ NGB.Contracts
│  ├─ NGB.Application.Abstractions
│  ├─ NGB.Runtime
│  ├─ NGB.Accounting
│  ├─ NGB.OperationalRegisters
│  ├─ NGB.ReferenceRegisters
│  ├─ NGB.Api
│  ├─ NGB.BackgroundJobs
│  ├─ NGB.Watchdog
│  ├─ NGB.PostgreSql
│  ├─ NGB.Persistence
│  ├─ NGB.Tools
│  └─ NGB.Migrator.Core
│
├─ Vertical solutions
│  ├─ NGB.AgencyBilling.*
│  ├─ NGB.PropertyManagement.*
│  └─ NGB.Trade.*
│
├─ UI workspace
│  ├─ ui/ngb-ui-framework
│  ├─ ui/ngb-agency-billing-web
│  ├─ ui/ngb-property-management-web
│  ├─ ui/ngb-trade-web
│  └─ ui/ngb-auth-theme
│
├─ Docker environments
│  ├─ docker-compose.ab.yml
│  ├─ docker-compose.pm.yml
│  └─ docker-compose.trade.yml
│
├─ Performance tests
│  ├─ performance-tests/ngb-performance-tests-framework
│  ├─ performance-tests/ngb-property-management-perf
│  ├─ performance-tests/ngb-trade-perf
│  └─ performance-tests/ngb-agency-billing-perf
│
└─ Tests
   ├─ Platform unit and integration tests
   └─ Vertical unit and integration tests

Technology stack

NGB is built with a practical, production-oriented stack:

Backend: .NET 10
Database: PostgreSQL
Schema versioning: Evolve
Authentication / SSO: Keycloak
Background jobs: Hangfire-based job infrastructure
Logging / observability: Serilog + Seq-friendly structured logging setup
Frontend: Vue 3 + Vite + Tailwind CSS + shared UI workspace
Containerized local environments: Docker Compose

Performance testing

NGB includes a reusable Grafana k6 + TypeScript performance testing framework under performance-tests.

The framework validates platform-level behavior and vertical-specific workloads with realistic business scenarios such as metadata and menu loading, document reads, document lifecycle operations, posting, audit reads, accounting effects, document flow, report execution, capacity staircases, breakpoint discovery, and opt-in write-heavy pressure.

Initial vertical coverage is provided for Property Management, with Trade and Agency Billing structured as extensions. Destructive write-heavy profiles are opt-in and excluded from the normal pm:all chain.

See:

Getting started

🔑 Demo access

The demo applications include a preconfigured administrator account for evaluation purposes.

Default demo user

Name: Alex Carter
Role: Admin
Email: alex.carter@demo.ngbplatform.com
Password: DemoAdmin!2026

This account is intended for demo and evaluation use only.

Prerequisites

You should have the following installed:

.NET SDK
Docker and Docker Compose
Node.js
PostgreSQL client tools if you want to inspect databases manually

Clone the repository

git clone https://github.com/ngbplatform/NGB.git
cd NGB

🔒 HTTPS certificates

The Docker Compose setup mounts ASP.NET certificates from ${HOME}/.aspnet/https. On a new machine, generate development certificates first if needed:

dotnet dev-certs https --trust

⚠️ Windows note

Before starting the application in Docker on Windows, ensure that the $HOME environment variable is set in the current PowerShell session.

Check the current value:

If it is not set correctly, define it manually:

[System.Environment]::SetEnvironmentVariable('HOME', $env:USERPROFILE.Replace('\', '/'), 'User')

Run the Property Management demo locally

docker compose -f docker-compose.pm.yml --env-file .env.pm up --build

Run the Trade demo locally

docker compose -f docker-compose.trade.yml --env-file .env.trade up --build

Run the Agency Billing demo locally

docker compose -f docker-compose.ab.yml --env-file .env.ab up --build

Build the .NET solution

Run backend tests

Run frontend workspace tests

cd ui
npm install
npm run test:all

Exact local environment details may evolve over time. The live demos are the fastest way to see the platform in action.

Design principles

NGB is built around a few strong principles:

1. Platform first

Shared cross-cutting capabilities belong in the platform, not duplicated across solutions.

2. Vertical-ready architecture

Industry solutions should extend the platform cleanly without turning the platform into vertical-specific code.

3. Accounting-aware business design

Accounting, registers, balances, and reporting are not afterthoughts. They are core platform concerns.

4. Metadata-driven UI and behavior

The platform should describe forms, lists, actions, and interactions as reusable metadata wherever that makes sense.

5. Durable system of record

PostgreSQL is the authoritative source of business truth.

6. Auditability and explainability

Business systems should make it possible to understand what happened, why it happened, and what effects were produced.

7. Production-minded engineering

The goal is not a demo-first framework. The goal is a reusable foundation for real business software.

Why Apache 2.0

NGB Platform is released under the Apache License 2.0.

This license was chosen to make the platform easy to adopt, easy to evaluate, and practical for real engineering teams. It allows commercial use, modification, and redistribution while preserving license and copyright notices.

See the LICENSE file for details.

Contributing

Contributions, discussions, issues, and pull requests are welcome.

If you want to explore NGB, the best starting points are:

the live demos;
the platform core projects in the solution;
the vertical solutions in NGB.PropertyManagement.*, NGB.Trade.* and NGB.AgencyBilling.*;
the shared UI workspace under ui/.

Suggested contribution areas:

documentation and developer onboarding;
platform features and infrastructure improvements;
UI/UX improvements;
new demo scenarios and example solutions;
test coverage and reliability improvements.

License

Licensed under the Apache License 2.0.

See:

推荐订阅源

Hacker News: Show HN

NGB Platform

NGB Platform Intro

Table of Contents

What is NGB Platform

Why NGB exists

Who NGB is for

What you can build with NGB

Core capabilities

Platform foundation

Business application model

Accounting and register engine

Reporting and analysis

Operations and platform services

Frontend and UX foundation

Live demos

🔑 Demo access

Explore NGB through live demo solutions

Architecture overview

High-level architecture

Architectural layers

Architecture flow

Monorepo structure

Technology stack

Performance testing

Getting started

🔑 Demo access

Prerequisites

Clone the repository

🔒 HTTPS certificates

⚠️ Windows note

Run the Property Management demo locally

Run the Trade demo locally

Run the Agency Billing demo locally

Build the .NET solution

Run backend tests

Run frontend workspace tests

Design principles

1. Platform first

2. Vertical-ready architecture

3. Accounting-aware business design

4. Metadata-driven UI and behavior

5. Durable system of record

6. Auditability and explainability

7. Production-minded engineering

Why Apache 2.0

Contributing

License

Links