What owners/managers can use today to prove sales, follow money, and review staff actions —
how Core Invoicing is the backbone, how tickets become billable invoices,
and where the product is still only partially instrumented.
Invoices = sales truthTicket bill → service invoiceAudit coverage is real but not universal
What management actually needs
Business question
GPE surface
How much did we sell today / this period?
Reports sales · Business Hub metrics · invoice aggregates
Show me one sale end-to-end
Invoice + payments + cart timeline + receipt
Who rang / voided / refunded this?
Audit logs (financial) · register shift · staff on invoice
Cash drawer accountability
Register open/close + shift history · cash tenders on invoices
Service job billed and paid?
Ticket bill + checkout → invoice · mark-paid
Crypto / gift / loyalty on a sale?
Payment lines on cart/invoice · gift/loyalty txns
Export for accountant / dispute
Audit export · reports · invoice list
Three layers of “truth” (do not mix them blindly)
flowchart TB
subgraph MONEY["1 · Money truth — canonical"]
INV[(Invoices + line items tenant main)]
PAY[Payments / tenders linked]
end
subgraph OPS["2 · Operational timeline"]
CART[pos_carts + cart events]
TT[transaction tracking timeline]
REG[register_shifts]
end
subgraph COMP["3 · Compliance / security audit"]
AL[(audit_logs · analytics DB)]
HR[hr_audit_log write-only]
end
POS[POS finalize] --> INV
POS --> CART
POS --> AL
TIX[Ticket bill checkout] --> INV
INV --> PAY
Layer
Question it answers
Where stored
1. Invoicing
What was sold, for how much, paid how, void/refund?
Tenant main · Invoices / line items
2. Transaction tracking
Cart lifecycle events (created, items, finalized)
Tracking service / timeline APIs
3. Audit logs
Who did security-sensitive / financial actions?
Tenant analytics · audit_logs
Owner playbook
For a disputed sale: start at invoice → payments → receipt →
register shift for that device/time → audit log filter Financial & POS →
optional cart timeline. Do not treat reports widgets alone as legal evidence without the invoice.
Core Invoicing system
Deliberate backbone: POS, kiosk, crypto, inventory adjustments, and
service tickets are supposed to create invoices through
CoreInvoicingService — single money language (cents, org, source, type).
Factory methods
Method
Source / type
Used by
createInvoice
generic
Core builder
createPOSSaleInvoice
source pos · type sale
POS cart finalize
createKioskOrderInvoice
kiosk
Kiosk checkout paths
createServiceTicketInvoice
source service_ticket · type service · metadata.ticketId
/api/invoices — list/create/get/update + payments on invoice
Receipts hang off invoice IDs (DocHub 23)
Void/refund should emit financial audit events (taxonomy includes INVOICE_VOID / INVOICE_REFUND)
Ticketing ↔ invoicing (billable tickets)
Bill API is first-class; Core link is incomplete
Service businesses can attach a bill to a ticket (line items, amount, status).
Checkout calls optional posInvoicing.createPosInvoiceForTicket — that module
does not exist on disk today, so many checkouts create no Core Invoice.
Mark-paid and crypto-invoice paths still work partially. Full readiness: DocHub 28.
flowchart TD
T[Service ticket]
B[bill.items · amountCts · status]
C[POST .../bill/checkout]
I[CoreInvoicingService.createServiceTicketInvoice]
INV[(Invoice source=service_ticket)]
P[Payments / mark-paid]
CRYPTO[POST .../invoice crypto]
T --> B
B --> C --> I --> INV
INV --> P
T --> CRYPTO
Ticket bill API (scopes tickets:read/write)
Endpoint
Purpose
GET /api/tickets/:id/bill
Read bill snapshot
POST …/bill/items
Set full item list
POST …/bill/add-item · remove-item · clear
Edit lines
POST …/bill/checkout
Create/reuse invoice from bill (POS invoice helper / service ticket)
POST …/bill/mark-paid
Mark bill paid with optional invoiceId
POST …/invoice
Crypto invoice for ticket amount
Appointment create can also spawn a ticket with ticketId/ticketNumber (DocHub 16) —
that ticket can then be billed the same way if the business uses invoice-style service work.
Not fully “one screen to rule them all”
Several parallel read models exist (same class of problem as dual reporting paths).
For ownership confidence, define a canonical story:
Invoice is money; tracking is cart timeline; audit is who/when for sensitive actions; reports are aggregates.
Audit system (compliance layer)
Storage
General audit_logs live in tenant analytics DB
(high-volume, off the hot POS path). Categories enum:
authentication, authorization, data_access, configuration, financial, system, general.
Inventory adjust / gift void / ticket bill checkout
verify per-path — not guaranteed universal
HR mutations
Separate hr_audit_log write-only (limited viewer)
OAO / coverage map already admits this
Audit “grows as more events call AuditService.” Taxonomy and query UI are strong;
coverage completeness is the open product work — not inventing an audit product from scratch.
Register & shift (cash accountability)
Open/close ceremony + admin force close create auditable register_shift rows and audit events.
Shift history CSV export supports EOD. See DocHub 14 / Appendix B.
Maturity assessment (ownership lens)
Capability
Grade
Notes
Invoice as sale backbone
Strong
POS + service ticket paths designed around Core Invoicing
Ticket billable workflow
Strong design
Full bill CRUD + checkout + crypto; UI/product polish may vary by tenant use
Owner sales reports
Good
Broad report tree; dual DB paths need reconciliation discipline
Transaction management void/refund
Present
Admin UI exists; always re-verify against live invoice after void
Audit log product
Infrastructure strong / coverage partial
Filters, export, presets ready; not every mutation audited yet
Single “transaction history” UX
Fragmented
Multiple APIs and screens; owners need a guided path
End-to-end re-verify gift/loyalty/ticket bill
Deferred in audit
Should be staged test scripts before “compliance ready” claims
What “fully thought through” still needs
Instrumentation matrix — spreadsheet of every money-moving and permission-changing
endpoint → must emit audit event type X (close taxonomy gaps).
Ticket billing UX polish — service desk bill editor → checkout → paid status
visible next to ticket; appointment-created tickets auto-open bill when appropriate.
Reconciliation report — invoices total vs payments vs register cash vs reports
for a date range (detect dual-path drift).
Retention & export policy — how long audit_logs / invoices kept; scheduled export.
Role matrix for who can void/refund/export — permission sets, not only admin role.
Automated tests — POS sale → invoice → audit row; ticket bill checkout → service invoice.