Glossary — every term explained
Imagine you just moved to a new town. Before you can find your way around, someone hands you a little map with the names of every street, shop, and bus stop written in plain words. This page is that map. Every time the rest of the handbook uses a word you don't recognize, come back here, look it up, and keep going.
Each entry has three parts:
- Plain meaning — one simple sentence anyone can follow.
- What it means here — how ASAB actually uses the idea in its own code.
- Where it shows up — a real file or folder so you can jump straight to the source.
ASAB is an ERP (see below) built in C# / .NET on the back end and Angular on the front end. The
code that matters lives under backend/. Read terms in any order — they cross-reference each
other.
How the pieces fit together
Before the A-Z, here is the 30-second picture. ASAB is one product that many separate companies ("tenants") rent. A company places orders, buys materials, makes things, and keeps its books — and the software remembers all of it, keeping each company's data walled off from every other company's.
Now the dictionary.
A
Aggregate
Plain meaning: a small family of data that always changes together and is protected as one unit, with one "head of the family" you talk to.
What it means here: a business object plus the rows that belong to it — for example a
PurchaseOrder together with its PurchaseOrderLine rows. You change the family through its head
(the "root"), never by reaching past it to a child. This keeps the rules in one place (Law 4, Single
Responsibility).
Where it shows up: backend/Modules/Procurement/ERP.Procurement.Entity/ (a purchase order
and its lines), backend/Modules/FinanceAccounting/.../Models/FxRevaluationRun.cs (a run and
its lines).
AR / AP (Accounts Receivable / Accounts Payable)
Plain meaning: AR is money other people owe you. AP is money you owe other people.
What it means here: when you sell on credit you create a receivable invoice (AR); when a vendor bills you, you create a vendor bill (AP). Both eventually become journal entries in the books and show up as outstanding balances until paid.
Where it shows up:
backend/Modules/FinanceAccounting/ERP.FinanceAccounting.Common/ReceivableInvoices/ (AR) and
backend/Modules/Procurement/.../VendorBill* (AP source).
B
BoM (Bill of Materials)
Plain meaning: the recipe for making a product — the list of ingredients and how much of each.
What it means here: a BillOfMaterials lists the component items and quantities needed to produce
one finished item. A work order (see below) consumes the BoM. ASAB's "V2" BoM also supports
sub-assemblies and subcontractors.
Where it shows up:
backend/Modules/Manufacturing/ERP.Manufacturing.Entity/Models/BillOfMaterials.cs,
.../BillOfMaterialsLine.cs, .../BillOfMaterialsSubcontractor.cs.
BRD (Business Requirements Document)
Plain meaning: the written wish-list a customer gave us describing what the software must do for their business.
What it means here: the two vertical packs (Alfawood, a furniture maker; InsuranceBroker) each came with a BRD. We track, item by item, whether the code actually satisfies each requirement in an "acceptance matrix". The BRD is the promise; the code is the proof.
Where it shows up:
docs/quality/erp-next/ALFAWOOD_BRD_ACCEPTANCE_MATRIX.md,
docs/quality/erp-next/INSURANCE_BROKER_BRD_ACCEPTANCE_MATRIX.md.
C
Chart of accounts (COA)
Plain meaning: the labelled folders your money lives in — "Cash", "Sales", "Rent", and so on.
What it means here: the list of accounting accounts a tenant uses. Every line of a journal entry
(see below) points at one of these accounts. ASAB models accounts and the moves against them with
Odoo-style names like AccountMove and AccountMoveLine.
Where it shows up:
backend/Modules/FinanceAccounting/ERP.FinanceAccounting.Entity/Configurations/AccountMoveConfiguration.cs,
.../AccountingJournalConfiguration.cs.
Command
Plain meaning: a written instruction that says "change something" — like a note that says "create this order".
What it means here: in ASAB's CQRS style, every write (create / update / delete) is a typed
...Command object. A command carries the data, a validator checks it, and a handler carries
it out. Commands never read for display — that is a query's job.
Where it shows up:
backend/Modules/CrmSales/.../CustomerPriceLists/Create/Command/CreateCustomerPriceListCommand.cs.
Control plane
Plain meaning: the building manager's office — it doesn't sell anything itself; it decides who gets which apartment and what features come with the lease.
What it means here: a separate application, 4EOrganizationsManager, that creates tenants, sets up their logins, and records what they paid for. The ERP itself (the "data plane" where customers do their actual work) trusts the control plane's decisions. They are deliberately different products with their own database — a core architecture rule.
Where it shows up:
backend/Applications/4EOrganizationsManager/, especially
.../FourE.OrganizationsManager.Workers/Provisioning/.
CQRS (Command Query Responsibility Segregation)
Plain meaning: keep the "change it" door and the "show it to me" door separate, so neither gets in the other's way.
What it means here: mandatory in ASAB. Writes use Command + Validator + Handler; reads use Query + Validator + Handler. Controllers are just the front door (HTTP) and do no business logic. This is the single most common shape you will see in every module folder.
Where it shows up: every module's *.Common project, e.g.
backend/Modules/Analytics/ERP.Analytics.Common/DashboardWidgets/Search/ with its
Command/Query, Validator, and Handler sub-folders.
CRM (Customer Relationship Management)
Plain meaning: the notebook where a company keeps track of every customer — who they are, what they want, what you've promised them, and what comes next.
What it means here (full picture): A CRM is the system a company uses to manage its relationships with the people it sells to. A real company uses it like this: a salesperson hears about a possible buyer and records a lead. If the lead looks serious it becomes an opportunity with an estimated value and a "stage" in a pipeline (early talk → proposal → won/lost). When the customer is ready to see numbers, the company sends a quotation (a formal price offer). If the customer says yes, the quotation becomes a sales order — a confirmed commitment that then triggers shipping, manufacturing, or invoicing. Throughout, the CRM remembers every conversation, who owns the deal, and what the next action is, so nothing falls through the cracks and managers can forecast revenue. In ASAB, all of this lives in the CrmSales module, which holds leads, opportunities, sales teams, quotations (with templates and approval tokens), customer price lists, and sales orders.
Where it shows up: backend/Modules/CrmSales/ — see .../Leads/, .../Opportunities/,
.../SalesQuotations/, .../SalesOrders/.
D
Dashboard / KPI
Plain meaning: a single screen with the big numbers a manager cares about — like a car's dashboard showing speed and fuel. A KPI ("Key Performance Indicator") is one of those numbers, such as "sales this month".
What it means here: the Analytics module builds dashboards out of "widgets", computes KPI tiles (including a comparison to a previous period), supports global filters, and lets you click a tile to "drill down" into the detail behind the number.
Where it shows up:
backend/Modules/Analytics/ERP.Analytics.Common/DashboardWidgets/,
.../Modules/Analytics/.../ExecuteDashboardHandler.cs.
E
EF Core (Entity Framework Core)
Plain meaning: a translator that turns C# objects into database rows and back, so programmers mostly write C# instead of raw database language.
What it means here: the only database access library allowed in ASAB. Each module configures its tables with EF "configuration" classes and ships schema changes as migrations (see below). Tables are designed to be tenant-safe and to enforce RLS.
Where it shows up: every *.Entity project, e.g.
backend/Modules/Inventory/ERP.Inventory.Entity/Configurations/StockOperationConfiguration.cs.
Entitlement
Plain meaning: the list of features a customer is actually allowed to use, based on what they paid for — like the channels included in your TV package.
What it means here: the control plane decides which modules a tenant may use; the ERP reads those entitlements and turns features on or off. The Auth module exposes an "entitlement reader" so any part of the system can ask "is this module switched on for this tenant?".
Where it shows up: backend/Modules/Auth/ERP.Auth.Common/EntitlementReader/,
backend/Host/ERP.Worker/Entitlements/.
Entity
Plain meaning: a thing the software remembers that has its own identity — a specific customer, a specific order — not just a number.
What it means here: a class that maps to a database table and is identified by an id (often a
tenant-scoped key). Entities live in each module's *.Entity project. An aggregate is one or more
entities governed as a unit.
Where it shows up:
backend/Modules/MasterData/ERP.MasterData.Entity/ (e.g. BusinessPartner... classes),
backend/Modules/Manufacturing/ERP.Manufacturing.Entity/Models/.
E-signature
Plain meaning: signing a document on a screen instead of with a pen on paper.
What it means here: the Documents module manages "signature envelopes" — a document sent out for signing, plus the events a signing provider reports back. This is how contracts and similar papers get legally signed inside ASAB.
Where it shows up:
backend/Modules/Documents/ERP.Documents.Entity/Configurations/SignatureEnvelopeConfiguration.cs,
.../SignatureProviderEventConfiguration.cs.
F
FX revaluation
Plain meaning: "FX" means foreign exchange (different currencies). At month-end you re-check what your foreign-currency balances are worth in your home currency, because exchange rates moved.
What it means here: a finance run that re-values open foreign-currency balances and books the
gain or loss. ASAB models this as an FxRevaluationRun with FxRevaluationLine rows.
FX revaluation is recently added — the AddFxRevaluationRuns migration is dated 2026-06-15. Treat
it as new and read the entity/handler code before relying on edge-case behavior rather than assuming
full month-end coverage.
Where it shows up:
backend/Modules/FinanceAccounting/ERP.FinanceAccounting.Entity/Models/FxRevaluationRun.cs,
.../Migrations/20260615065031_AddFxRevaluationRuns.cs.
H
Handler
Plain meaning: the worker who actually does the job written on a command or query.
What it means here: the class that executes a command (perform the change) or a query (fetch the data). It runs after the validator approves the request. Handlers hold the business logic; controllers do not.
Where it shows up:
backend/Modules/CrmSales/.../CustomerPriceLists/Create/Handler/CreateCustomerPriceListHandler.cs.
I
Idempotency
Plain meaning: doing the same thing twice has the same result as doing it once — like a light switch already "on": flipping it to "on" again changes nothing.
What it means here: messages can be delivered more than once, so consumers must not double-apply them. ASAB records each handled message in an inbox and refuses to process a duplicate. This makes retries safe (a Law: idempotency for retried state changes).
Where it shows up:
backend/Modules/.../Messaging/InboxMessageRecorder.cs under
backend/ERP.Shared/ERP.SharedInfrastructure/Messaging/, and the duplicate-rejection test
.../InboxRecorderDuplicateTests.cs.
Integration event
Plain meaning: a little announcement one part of the system shouts so other parts can react — "a sales order was confirmed!" — without the shouter knowing or caring who is listening.
What it means here: modules do not call each other's internals. Instead they publish typed integration events (wrapped in an "envelope" with id, type, tenant, etc.) and other modules consume them. This keeps modules independent. Compare with outbox (how the event leaves) and inbox (how it is safely received once).
Where it shows up:
backend/ERP.Shared/ERP.SharedKernel/IntegrationEvents/IntegrationEventEnvelopeValidator.cs,
backend/ERP.Shared/ERP.SharedKernel/Workers/RuntimeIntegrationEventDispatcher.cs.
J
Journal entry
Plain meaning: a single balanced note in the accounting books — every entry has equal "money in" and "money out" so the books always balance.
What it means here: ASAB calls it an AccountMove (the entry) made of AccountMoveLine rows (the
debit/credit lines), following Odoo-style naming. Invoices, bills, payments, and FX revaluations all
end up as account moves in the ledger.
Where it shows up:
backend/Modules/FinanceAccounting/ERP.FinanceAccounting.Entity/Configurations/AccountMoveConfiguration.cs,
.../AccountMoveLineConfiguration.cs.
M
Migration
Plain meaning: a step-by-step recipe for changing the shape of the database — adding a table, a column, a rule — without losing what's already stored.
What it means here: every schema change is an EF Core migration file with a timestamp. ASAB does not auto-run migrations on normal startup; they are applied deliberately. Each module owns its own migration history.
Where it shows up: any *.Entity/Migrations/ folder, e.g.
backend/Modules/FinanceAccounting/.../Migrations/20260615091732_AddWithholdingTax.cs.
Multi-tenant
Plain meaning: one big apartment building where many families live separately. Same building, same plumbing — but each family has its own locked door.
What it means here: one running ASAB instance serves many customer companies at once. The "shared building" is the code and infrastructure; the "locked doors" are tenant isolation enforced by RLS. Saving money on infrastructure is the point; never leaking one tenant's data into another's is the hard rule.
Where it shows up: tenant binding lives in
backend/ERP.Shared/ERP.SharedInfrastructure/Tenancy/TenantRlsTransaction.cs.
O
Outbox
Plain meaning: a mailbox by your front door. You drop the letter in the same trip you finish the task, and a postman picks it up later — so the letter and the task succeed or fail together.
What it means here: when a handler changes data and wants to publish an integration event,
it writes the event into an OutboxMessage table inside the same database transaction as the data
change. A separate outbox dispatcher later sends it. This guarantees the event is never lost and
never sent for a change that rolled back.
Where it shows up:
backend/ERP.Shared/ERP.SharedInfrastructure/Messaging/OutboxMessage.cs,
.../OutboxMessageAppender.cs, .../OutboxDispatcher.cs.
P
Provisioning
Plain meaning: setting up everything a new customer needs on their first day — like preparing a hotel room before a guest arrives.
What it means here: when a tenant is created (often after payment), the control plane runs a multi-step "provisioning saga" that creates their login realm (Keycloak), grants the first admin role, and records the result — failing loudly if any step breaks rather than half-setting-up a tenant.
Where it shows up:
backend/Applications/4EOrganizationsManager/FourE.OrganizationsManager.Workers/Provisioning/
(see ProvisioningSagaWorkerService.cs, KeycloakPrimaryUserProvisioningStepExecutor.cs).
Purchase order (PO)
Plain meaning: the official "yes, please send us these goods at this price" you give to a supplier.
What it means here: a PurchaseOrder with PurchaseOrderLine rows, created in the Procurement
module (often after comparing RFQ quotes). It has a send lifecycle and is one of the three papers
checked in a 3-way match.
Where it shows up:
backend/Modules/Procurement/ERP.Procurement.Entity/Configurations/PurchaseOrderConfiguration.cs,
.../Migrations/20260615084005_AddPurchaseOrderSendLifecycle.cs.
Q
Quotation
Plain meaning: a written price offer — "here's what it would cost you" — that the customer can accept or decline.
What it means here: a SalesQuotation in the CrmSales module, with lines, taxes, optional
templates, and approval/decision tokens for the customer to confirm. When confirmed it becomes a
sales order.
Where it shows up:
backend/Modules/CrmSales/ERP.CrmSales.Entity/Configurations/SalesQuotationConfiguration.cs,
.../Workers/QuotationConfirmation/QuotationConfirmationRequestedConsumer.cs.
Query
Plain meaning: a request that only asks to see data and never changes anything — like reading a page, not writing on it.
What it means here: the read half of CQRS. A ...Query object plus its validator and handler
fetch and shape data for display. Queries must not have side effects.
Where it shows up:
backend/Modules/Analytics/.../DashboardWidgets/Search/ (the Search query, validator, handler).
R
Replenishment
Plain meaning: restocking — noticing the shelf is getting empty and arranging more before you run out.
What it means here: the Inventory module raises "replenishment demands" when stock falls below need, then proposes how to cover them — by transfer, purchase, or manufacture — and the matching modules pick up that demand.
Where it shows up:
backend/Modules/Inventory/ERP.Inventory.Common/Workers/InventoryReplenishmentSchedulerWorkerService.cs,
.../Entity/Configurations/InventoryReplenishmentDemandConfiguration.cs.
Retention
Plain meaning: keeping records for as long as the rules say you must, then being allowed to clear them — like a school keeping report cards for a set number of years.
What it means here: in the Documents module, document categories carry retention information so files are kept for their required period.
Retention in ASAB is currently a category-level attribute on stored documents
(DocumentCategoryConfiguration.cs), not a fully automated delete-on-expiry engine. Confirm in code
before promising customers automatic purging.
Where it shows up:
backend/Modules/Documents/ERP.Documents.Entity/Configurations/DocumentCategoryConfiguration.cs.
RFQ (Request for Quotation)
Plain meaning: asking several suppliers "how much would you charge for this?" before you decide who to buy from.
What it means here: a "sourcing event" in Procurement: you invite candidate vendors, collect their quotes, compare them, and award the winner — which then becomes a purchase order.
Where it shows up:
backend/Modules/Procurement/ERP.Procurement.Utility/RfqQuoteComparer.cs,
.../Entity/Configurations/RfqSourcingEventConfiguration.cs.
RLS (Row-Level Security)
Plain meaning: the database itself refuses to show you rows that aren't yours — like a fridge that only opens the shelf with your name on it.
What it means here: the core defence that keeps tenants apart. Before any query runs, ASAB sets
the tenant id on the database connection (set_config('app.tenant_id', …)) inside a transaction, and
PostgreSQL row-level-security policies hide every other tenant's rows. There is exactly one place
allowed to write that binding, and an architecture test fails loudly if anyone re-introduces it
elsewhere (Law 1, Single Source of Truth). An empty tenant id throws rather than silently binding
nothing.
Where it shows up:
backend/ERP.Shared/ERP.SharedInfrastructure/Tenancy/TenantRlsTransaction.cs, guarded by
.../ERP.SharedInfrastructure.Tests/Tenancy/TenantRlsBindingArchitectureTests.cs.
Routing
Plain meaning: the order of steps on the factory floor to make a product — cut, then sand, then paint — and which station does each.
What it means here: a Routing made of RoutingOperation rows in Manufacturing, describing the
operations a work order follows. Operations can carry instruction steps and capture operator time
and evidence.
Where it shows up:
backend/Modules/Manufacturing/ERP.Manufacturing.Entity/Models/Routing.cs,
.../RoutingOperation.cs.
S
Sales order (SO)
Plain meaning: a confirmed deal — the customer said yes, so now we owe them the goods or service.
What it means here: a SalesOrder (with lines, addresses, taxes) created when a quotation is
accepted. It can trigger fulfillment, down-payment calculation, manufacturing, or invoicing.
Where it shows up:
backend/Modules/CrmSales/ERP.CrmSales.Entity/Configurations/SalesOrderConfiguration.cs,
.../Workers/SalesOrderFulfillment/SalesOrderFulfillmentRequestedConsumer.cs.
Stock operation
Plain meaning: any single movement of goods in the warehouse — receiving, shipping, moving from shelf to shelf, or adjusting a count.
What it means here: a StockOperation with StockOperationLine rows in Inventory. Each
operation type defines what kind of movement it is, and posting one updates quantities and triggers
valuation.
Where it shows up:
backend/Modules/Inventory/ERP.Inventory.Entity/Configurations/StockOperationConfiguration.cs,
.../Api/Controllers/StockOperationsController.cs.
T
Tenant
Plain meaning: one customer company renting space in the shared building — the family behind one locked door (see multi-tenant).
What it means here: the unit of isolation. Almost every row carries a tenant id, every request runs bound to one tenant, and RLS makes that binding the line nothing crosses. The control plane creates and manages tenants.
Where it shows up: binding in
backend/ERP.Shared/ERP.SharedInfrastructure/Tenancy/; lifecycle in
backend/Applications/4EOrganizationsManager/.
3-way match
Plain meaning: before paying a supplier, you line up three papers — what you ordered, what you received, and what they billed — and only pay if all three agree.
What it means here: Procurement compares the purchase order, the goods receipt, and the vendor bill, applying configurable tolerances. If they match within tolerance the bill can flow to Finance; if not, it is flagged or needs an override. This stops overpayment and fraud.
Where it shows up:
backend/Modules/Procurement/ERP.Procurement.Utility/PurchaseMatchCalculator.cs,
.../Entity/Configurations/PurchaseMatchToleranceConfiguration.cs,
.../Tests/Application/ProcurementThreeWayMatchTests.cs.
V
Validator
Plain meaning: the gatekeeper who checks a request is sensible before anyone acts on it — like checking a form is filled in correctly before processing it.
What it means here: every command and query has a validator that enforces the rules and returns typed failures (Law 6, Fail Loud / Fail Early). The handler only runs if the validator passes.
Where it shows up:
backend/Modules/CrmSales/.../CustomerPriceLists/Create/Validator/CreateCustomerPriceListValidator.cs,
and per-module behavior interfaces like .../Behaviors/ICrmSalesRequestValidator.cs.
Valuation
Plain meaning: working out how much the stuff sitting in your warehouse is worth in money.
What it means here: the Inventory module keeps "valuation layers" and supports three costing methods: Standard (a fixed planned cost, with the difference booked as a price-difference variance), Average (a running average cost per item/warehouse), and FIFO ("first in, first out"). Receipts and issues update the value, which then feeds the accounting books.
Where it shows up:
backend/Modules/Inventory/ERP.Inventory.Common/InventoryValuationLayers/InventoryValuationCosting.cs,
.../Entity/Configurations/InventoryValuationLayerConfiguration.cs.
Vendor bill
Plain meaning: the invoice a supplier sends you asking to be paid.
What it means here: a VendorBill with VendorBillLine rows in Procurement, the AP side
of a purchase. It is one of the three papers in a 3-way match and, once matched, is handed off to
Finance to become a journal entry. Payment terms are resolved from the supplier at handoff.
Where it shows up:
backend/Modules/Procurement/ERP.Procurement.Entity/Configurations/VendorBillConfiguration.cs,
.../Migrations/20260526001922_AddProcurementVendorBillFinanceHandoffState.cs.
Vertical pack
Plain meaning: an industry-specific add-on that sits on top of the general ERP — like a phone case made for one exact phone model.
What it means here: packs such as Alfawood (furniture manufacturing) and InsuranceBroker extend the generic core for one industry. A firm rule: a vertical pack must not duplicate or own core ERP behavior — if a reusable capability is missing, that is a core backlog item, never a vertical workaround.
Where it shows up: backend/Modules/Alfawood/, backend/Modules/InsuranceBroker/.
W
Withholding tax
Plain meaning: holding back a slice of a payment to hand to the tax authority on the other party's behalf, instead of paying them the full amount.
What it means here: a tax behavior configured in FinanceAccounting so that, where required, a portion of a payment is withheld and accounted separately.
Withholding tax is recently added (the AddWithholdingTax migration is dated 2026-06-15) and is
defined via tax definitions in Finance. Read TaxDefinitionConfiguration.cs and the related handlers
before assuming full reporting/remittance coverage.
Where it shows up:
backend/Modules/FinanceAccounting/ERP.FinanceAccounting.Entity/Migrations/20260615091732_AddWithholdingTax.cs,
.../Entity/Configurations/TaxDefinitionConfiguration.cs.
Work order
Plain meaning: the factory-floor instruction that says "make this many of this product, starting now".
What it means here: a WorkOrder in Manufacturing that consumes a BoM (the recipe) and
follows a routing (the steps). It records scheduling attempts, execution events, operator time, and
instruction evidence, and consuming/producing it moves stock.
Where it shows up:
backend/Modules/Manufacturing/ERP.Manufacturing.Entity/Models/WorkOrder.cs,
.../WorkOrderExecutionEvent.cs, .../WorkOrderOperatorTimeEntry.cs.
One more time: ERP
ERP (Enterprise Resource Planning)
Plain meaning: one big shared notebook for running a whole company — sales, buying, making things, stock, and money — so everyone writes in the same book instead of keeping separate scraps of paper.
What it means here: ASAB is an ERP. The modules under backend/Modules/ are the chapters of
that notebook: CrmSales (selling), Procurement (buying), Manufacturing (making),
Inventory (stock), FinanceAccounting (money), plus supporting chapters like MasterData,
Documents, Analytics, Workflow, Collaboration, and Auth. The whole thing is
multi-tenant, so the one notebook safely serves many companies at once.
Where it shows up: the whole of backend/. ERP.Next is the current core product;
src/Backend (the older ERP.SaaS) is a legacy/logic reference only.
This glossary describes what the code does today. If you change behavior in the source, update the matching entry here so the map never lies about the town.