REDA One Help Center
EN
Language
English EN Español ES Português PT Italiano coming soon Français FR Deutsch coming soon العربية coming soon
reda.one ↗
Home / REDA Financials AI / General Ledger / Posting Engine / Posting Dimensions

Posting Dimensions

A posting dimension is an extra way to slice your numbers — by department, project, cost centre, property, region, or anything else your business reports on. Your chart of accounts tells you what a transaction is (revenue, rent, salaries). A dimension tells you which part of the business it belongs to — without exploding your chart into hundreds of near-duplicate accounts like “Rent – London”, “Rent – Paris”, “Rent – New York”.

REDA carries your dimensions all the way down to the individual ledger entry, automatically, using a configurable posting map — the list of fields that flow from a document to the ledger. This article is the complete reference: which records carry the posting map, how the dimension match runs at posting time for every kind of document (including assets), and how an administrator sets one up — all with no code.

The mechanism in one sentence. Add a matching field — with the same underlying name — to a source document and to the ledger entry, list it in the posting map on each, and the posting engine copies the value from document to ledger every time you post — forever, with zero programming.

Why dimensions instead of more accounts

Imagine you rent offices in three cities and want rent reported per city. You have two choices:

More accountsOne account + a dimension
Chart of accountsRent – London, Rent – Paris, Rent – NY… (grows forever)One “Rent” account
To add a cityCreate new accounts, retrain everyoneJust pick the new city in the Location field
ReportingSum groups of accounts manuallyGroup the one account by the dimension
Cross-analysisHard — account explosion multipliesEasy — slice the same ledger by any dimension

Dimensions keep your chart of accounts clean and your analysis flexible — standard practice in every serious ERP. REDA just makes it configuration, not a project.

Where the posting map lives

The posting map exists on 16 record types, and they don’t all play the same part. There’s one destination, a set of posting sources the engine reads at post time, and a few records that carry the posting map purely so your dimensions stay consistent for reporting and matching. Know which is which and the whole system makes sense.

1. The destination — where dimensions land

RecordRole
Accounting TransactionThe target. Every dimension you want on the ledger must exist here as a field and be listed in this record’s posting map. The standard accounting fields (Entity, GL Account, Period, Ledger) are not dimensions — the engine maps those directly, so never add them to the posting map.

2. Posting sources — read at post time

When you post one of these, the engine reads its posting map and stamps the values onto the resulting transactions:

RecordLevelNotes
Sales InvoiceHeaderAlso covers Credit Memos (a Sales Invoice of that type).
Purchase InvoiceHeaderAlso covers Vendor Memos (a Purchase Invoice of that type).
Journal EntryHeaderPairs with the line below — the only document with per-line dimensions.
Journal Entry LineLineLine values override the JE header for the same field.
Cash ReceiptHeaderFeeds both the receipt’s own entries and its applications.
Cash DisbursementHeaderFeeds both the payment’s own entries and its applications.
Fixed AssetHeaderSource for all asset entries — depreciation, disposal, impairment, capitalization.
Purchase OrderHeaderNot posted directly — dimensions propagate to matched Purchase Invoice lines (see below).

3. Expense Allocation — propagated through a journal

RecordFlows to
PI Allocation BatchThe generated Journal Entry header
PI AllocationThe generated Journal Entry line (overrides header)
Expense Allocation ItemCarries dimensions through the allocation calculation

Expense allocation doesn’t post directly — it builds a Journal Entry and lets that post. The allocation’s dimensions ride onto the JE header and lines, so the final ledger entries inherit them exactly as any journal would.

4. Parity & matching — they carry dimensions, but no posting

RecordWhy it carries the dimensions
Budget & Budget LineSo budgeted figures carry the same dimensions as actuals — budget-vs-actual then compares like-for-like by department, project, etc. Budgets never create Accounting Transactions.
Aging Snapshot LinePoint-in-time AR/AP reporting rows carry the same dimensions so aging can be sliced the same way as the live ledger.
Bank Account RuleLets bank-reconciliation auto-match rules reference your dimensions when proposing matches.

How matching runs — document by document

At posting, the engine merges the dimensions from a header source and (where one exists) a line source, then stamps the result on each transaction. What counts as the header and the line differs by document — and that difference is the single most important thing to understand here:

When you post…Header dimensions fromLine dimensions fromNet result
Sales Invoice / Credit MemoThe invoice header— (SI lines carry no dimensions)Every entry inherits the invoice’s dimensions
Purchase Invoice / Vendor MemoThe bill header—Every entry inherits the bill’s dimensions
Journal EntryThe JE headerThe JE linePer-line dimensions — line wins where set, else header flows down
Cash ReceiptThe receipt header—Receipt’s dimensions on its entries
Cash Receipt ApplicationThe parent Cash Receipt—Application entries inherit the receipt’s dimensions
Cash DisbursementThe payment header—Payment’s dimensions on its entries
Cash Disbursement ApplicationThe parent Cash Disbursement—Application entries inherit the payment’s dimensions
Credit Memo ApplicationThe parent Credit Memo—Inherit the memo’s dimensions
Vendor Memo ApplicationThe parent Vendor Memo—Inherit the memo’s dimensions
Fixed Asset (depreciation, disposal, impairment, capitalization)The Fixed Asset header—Every asset entry inherits the asset’s dimensions
Header-level on invoices is deliberate — it keeps dimensions in balance. A document’s debit and credit sides must net to zero within every dimension, not just overall. If a sales invoice could send each revenue line to a different cost centre while the single receivable line carried just one, the cost-centre ledger would no longer balance. Stamping one set of dimensions across the whole invoice guarantees that every dimension nets to zero on every document. The Journal Entry is the one exception: there the preparer authors each line explicitly and is responsible for keeping the dimensions balanced — which is exactly why it’s the only document with per-line dimensions.
Why applications inherit from the parent. A cash receipt application (and a credit/vendor-memo application) is a small link record, not a document you’d dimension yourself. So the engine reaches up to the parent — the Cash Receipt, the Cash Disbursement, the Memo — and stamps its dimensions onto the application’s entries. Set the dimension once, on the parent, and every downstream entry follows.

Assets: the dimension source is the Fixed Asset

Asset entries deserve a special mention because people expect them on the asset ledger. They’re not. The Asset Ledger record carries no dimensions of its own — instead, every asset transaction (a depreciation charge, a disposal gain/loss, an impairment, a capitalization) takes its dimensions from the Fixed Asset itself. And because an asset is usually born from a Purchase Order, dimensions cascade the whole way:

Purchase Order header  →  Fixed Asset  →  Accounting Transaction
Set Cost Centre = Operations on the PO, and it flows onto the asset at creation, then onto every depreciation entry the asset ever generates — no re-keying, for the life of the asset.

Purchase Orders: dimensions propagate, they don’t post

A Purchase Order is off the balance sheet — it never creates ledger entries on its own. Its posting map exists so that when a Purchase Invoice is matched against the PO, the PO’s dimensions flow onto the matched PI lines. The dimensions then stamp onto the ledger when the Purchase Invoice posts — the PO seeds them, the PI delivers them.

The merge rule, precisely

For any post, the engine resolves each dimension like this:

Header is the base. Read every field in the header source’s posting map.
Line overrides where present. If there’s a line source (only Journal Entry Lines today), a non-blank line value replaces the header value for that field.
Match by field name. Each merged value is written to the field with the same underlying name on the Accounting Transaction.
No match → skipped silently. If the Accounting Transaction has no field of that name, the value is dropped harmlessly — nothing errors.
Blanks become null. An empty lookup value is stored as null rather than an empty string, so the ledger stays clean.
Identical field names on both sides are non-negotiable. The copy works only by matching the field’s underlying name. If you create a Cost Centre field on the invoice, the field you create on the Accounting Transaction must carry the exact same underlying name. A mismatch means the value silently won’t carry — the single most common setup slip.

Setting up a new dimension (administrator)

To analyse everything by, say, Cost Centre, an administrator does this once:

Add the field to the Accounting Transaction. Create a Cost Centre field (lookup, picklist, or text) and add it to the Accounting Transaction’s posting map. This is the destination.
Add the same field (identical underlying name) to each source you want it to flow from — Sales Invoice, Purchase Invoice, Journal Entry (header and line), Cash Receipt, Cash Disbursement, Fixed Asset, Purchase Order — and put it in each one’s posting map.
Surface it on the forms. REDA’s source forms render the document’s configurable set of on-screen fields, so add the field there to let users fill it in on the entry screen.
Add it to reports. Group any financial report by the new field — and add it to Budget/Budget Line and Aging Snapshot Line if you want budget-vs-actual and aging sliced the same way.

From the next post onward, every ledger entry carries the Cost Centre. No release, no developer, no downtime.

One field, picked once. You don’t have to add a dimension to every source — only the documents where it’s relevant. A “Project” dimension might live only on Sales Invoices and Journal Entries if that’s where project activity originates. Start narrow and extend as needed.
A dimension field that is a formula or a roll-up is fine — it is simply left alone. When REDA copies your dimensions onto the accounting entries, it now checks whether the destination field can actually be written and skips it if it cannot. Formula and roll-up fields compute their own values, exactly as they are meant to. Before version 1.610 the copy attempted the write anyway and the whole operation failed — most visibly when voiding a cash receipt. A field list that mixes writable and calculated fields is now perfectly safe.

Dimensions, grouping, immutability & reporting

  • They’re part of grouping. When grouped posting is on, lines are only summarised together if they share the same account and the same dimension values. Two rent lines for different cost centres stay separate — you never lose the breakdown to summarisation.
  • They’re immutable like every ledger field. Once stamped, a dimension on an Accounting Transaction can’t be edited — and any dimension you add to the Accounting Transaction’s posting map is automatically locked, with no extra setup.
  • They power your reports. Because the value lives on every entry, you can produce a P&L by department or a cost report by project — and, because Budget and Aging records carry the same dimensions, compare those to budget and trace them through aging.
  • They can scope the year-end close. The Year-End Close screen offers optional Dimension Filters built from these same fields — you can close the profit and loss for selected dimension values only, and the closing journal lines carry the chosen values.
The same pattern powers extension packages. This configuration-driven approach is how REDA stays extensible without forking the core: a partner’s extension package adds its own dimensions (or PDF columns, or on-screen fields) purely by dropping fields into the right configurable lists. The engine picks them up automatically.

Where to go next

  1. How Posting Works — where dimensions attach during posting.
  2. Accounting Transactions — the lines dimensions tag.
  3. Grouped vs Line-Level Posting — how dimensions affect grouping.
  4. Chart of Accounts Setup Best Practices — dimensions instead of extra accounts.
  5. Report Filters — slice reports by dimension.

Frequently asked questions

No — and this is by design, not a limitation. Sales Invoices and Purchase Invoices stamp dimensions at the header level so the document stays balanced within every dimension: the receivable (or payable) side and the revenue (or expense) side carry the same dimension values, so each dimension nets to zero. Allowing different dimensions per invoice line would leave the single AR/AP line out of balance against the split revenue/expense lines. The Journal Entry is the one document with true per-line dimensions — because there the preparer authors each line and owns keeping the dimensions balanced. If you need genuinely line-by-line dimensional control, a Journal Entry is the right tool.

From the Fixed Asset record — not the asset ledger, which carries no dimensions of its own. Dimensions flow Purchase Order → Fixed Asset → ledger entry, so every depreciation, disposal, impairment, and capitalization entry inherits the asset’s dimensions automatically for the life of the asset.

Almost always one of three things: (1) the field’s underlying name differs between the source document and the ledger entry; (2) the field isn’t in the posting map in both places; or (3) you added it to a source that doesn’t post directly (e.g. a Purchase Order — its dimensions only appear once the matched Purchase Invoice posts). A value with no matching ledger field is skipped silently by design.

No. It’s pure configuration — create matching fields, add them to the posting map on both sides, and surface them on the form. The posting engine handles the copy with no code.

For parity. Budgets carry the same dimensions as actuals so budget-vs-actual compares like-for-like, and aging snapshots carry them so period-end AR/AP can be sliced exactly as the live ledger. They never create Accounting Transactions — the dimensions just keep your analysis consistent across the app.

Was this article helpful?