Distinguishing the period a transaction belongs to from the moment it was recorded.
How a caller — an LLM-driven parser or a program — invokes a live action or read against an external system at request time, as distinct from a scheduled or…
How aggregate and reporting queries are served without harming transactional performance.
The contract between client and server.
How the rules determining who must approve what are expressed and evaluated.
What is recorded about who did what, and how tamper-resistant that record is.
How users prove identity.
How permissions are expressed and evaluated.
The primary server-side language, which shapes hiring, library availability and the ML story.
Recovery objectives and how they are met and proven.
Coordinating multi-stage pipelines with dependencies — ingest, normalise, match, generate entries.
Computing 'close day 3' when entities sit in different countries with different holidays.
Whether logic lives in services, in the database, in a domain model, or is scattered through controllers.
What is cached, where, and how it is invalidated.
Where models are trained, how artefacts are stored and versioned, and how retraining is triggered.
How server data, filters, selections and optimistic updates are held on the client.
Which third-party attestations the product must carry.
Where application and worker processes run.
How configuration moves from a test environment to production.
How configuration changes are reviewed, approved, recorded and rolled back.
Proving that matching, tolerance and arithmetic behave correctly across edge cases.
Keeping infrastructure and model spend proportionate to revenue.
Understanding what the system costs, and attributing it.
How customers get their data into their own analytics tools.
The component handling large, sortable, filterable, groupable tabular views with inline editing.
Detecting bad input data before it corrupts downstream processing.
Where a tenant's data physically resides and is processed.
Applying schema changes without breaking a running system or a close in progress.
Covering absent approvers without breaking the control.
Whether to adopt, extend or build the visual component set.
Producing spreadsheets, PDFs and audit packages for download.
Where uploaded evidence and generated outputs are stored.
Monitoring business correctness, not just system health.
How data is protected at rest and in transit, and who holds the keys.
How the platform determines that two records in two different systems, with no shared universal identifier, refer to the same real-world entity — which…
How the system exchanges data with customer ERPs.
When to notify immediately, when to batch, and how escalation chains are defined.
What happens when an external system is unavailable, slow or rejects a request.
Where the inputs to models are computed and held.
Releasing change to a subset of tenants before all of them.
Accepting and parsing incoming data files in varied formats.
Ensuring a re-run does not double-process, double-post or duplicate entries.
How infrastructure is defined and changed.
Ensuring connectors keep working when external systems change.
Whether data moves in batches or continuously.
What actually prevents a query from returning another tenant's rows.
How background work is enqueued, executed and retried.
How generative models are called, and what happens to the data sent to them.
Verifying behaviour at production data volumes.
The shape of demand the system must absorb, and how capacity follows it.
How a developer runs the system on their own machine.
How model-generated content is marked, reviewed and audited.
Whether one model serves all tenants or each tenant has its own.
Whether records are updated in place or history is preserved.
Preventing one tenant's workload from degrading service for others.
Channels and transport for telling users something needs attention.
How money is represented in storage and in computation.
How the system knows whether a write to an external system actually succeeded.
Where authorisation is actually evaluated for a search or retrieval index built continuously from external systems the platform does not own, and how…
How code moves from commit to production.
The system of record for transactional data.
Data that is correct only for a period — exchange rates, tax rates, org structures, account mappings.
When it is safe to release.
How inputs are validated and how types are shared between client and server.
How long data is kept, and how deletion is prevented when it must not occur.
How schema changes are authored, reviewed and applied.
How records are found across large volumes.
Monolith, modular monolith, or services — and where the seams are if any.
How developers work against ERPs, banks and processors they cannot run locally.
How valid state transitions are declared and prevented from being bypassed.
How events are logged and traced across a request or a batch run.
How very large transaction tables are physically divided.
Where per-tenant rules, templates, thresholds and approval matrices live.
How one tenant's data is kept separate from another's at the storage layer.
How instants are stored and returned.
Whether the interface is server-rendered, a single-page application, or a hybrid, and which framework delivers it.
How multi-step processes with human approval steps, timeouts and escalation are executed and resumed.