Skip to content
ERRNAInsight Center

ERRNA expert insight

Maker-Checker Controls for Crypto Exchange Back Offices: A CISO's Design for Payload-Bound Approvals

By Akeel Q.November 16, 202625 min readBlockchain

Direct answer: a maker-checker control on a crypto exchange back office works only when the approval is bound to the exact payload that will execute, the approver is a different authenticated person from the requester, and a separate service executes that payload once, under an atomic claim, with an authoritative record of the outcome. Anything weaker is a policy document with a button on it.

This article is written for the CISO or security lead who owns the answer to one uncomfortable audit question: "Show me that no single person, session, or script could move customer value or change a control on your platform without a second, independent approval of exactly what happened." Admin consoles on digital asset platforms can post manual ledger adjustments, release held withdrawals, change withdrawal allowlists, enable assets, override KYC states, and grant roles. They are the most consequential mutation surface you operate, and often the least engineered one.

We lay out a proposed design (not an established, proprietary Errna method) that you can adapt: tiered mutation classes, canonical payload hashing, identity separation, atomic claiming, reconciliation of unknown outcomes, tenant-safe idempotency, and privacy ownership for the approval records themselves. It closes with an all-required go/no-go checklist. It is not a scorecard, and it does not certify production readiness.

  • Scope: back-office and operator-initiated mutations, not customer-initiated trading or custody key ceremonies.
  • Standards cited are scoped to what they actually say, and none of this is legal advice.
  • Examples are illustrative composites, not customer results.

Key Takeaways (BLUF)

  • Approve the payload, not the ticket. If the checker approves a reference and the maker can still change the content, you have a four-eyes ritual, not a control.
  • Bind approval to an immutable hash of a canonical, versioned payload. Any edit creates a new operation that needs fresh approval.
  • Separate three identities: maker, checker, and executor. Humans never hold direct write access to the ledger path.
  • Claim work atomically with a conditional database write, and make the target side (ledger, custody) enforce the same tenant-scoped operation identity.
  • Never blindly retry an ambiguous timeout. Unknown means completion could not be confirmed. Reconcile against the authoritative record first.
  • Approval records are sensitive data. Wallet addresses, user IDs, and KYC notes can be personal data, so assign an owner for retention, access, and redaction.
  • Use mandatory go/no-go controls. One failed control means no-go for the affected mutation class.

Why the Back Office Is the Softest Target on a Digital Asset Platform

Key takeaway: Customer-facing paths get penetration tests and rate limits. Operator paths often get a role and a trust assumption. Treat every operator mutation that can move value, loosen a control, or change a customer's status as a regulated-grade change.

Exchanges invest heavily in matching engines, wallets, and perimeter security. The back office is where operations teams fix real problems: a deposit that did not credit, a stuck withdrawal, a mis-set fee tier, a customer who needs a frozen account released. Each fix is a legitimate reason to mutate production state, which is exactly why the same console is attractive to an insider, a phished operator, or a compromised session.

Two properties make this surface hard. First, the actions are consequential and often irreversible: a posted ledger adjustment can be reversed only by another posting, and a broadcast on-chain transaction cannot be recalled. Second, the actions are ambiguous under failure: a request that times out may or may not have been applied, and an operator's natural reflex is to click again.

Standards bodies describe the principle plainly. NIST SP 800-53 control AC-5 asks organizations to identify and document the duties that require separation and to define access authorizations to support that separation (see the NIST SP 800-53 Rev. 5 publication page). ISO/IEC 27002:2022 control 5.3 on segregation of duties lists examples such as initiating, approving, and executing a change, and notes that where segregation is hard, compensating controls like monitoring, audit trails, and management supervision should be considered (see the ISO/IEC 27001 standard page for the family of documents). Neither tells you how to build it for an exchange. That gap is where platforms fail audits.

Mutation inventory: start here

You cannot tier what you have not listed. This inventory table is a starting point for your own register. Tiers are proposals for your risk committee to set, not regulatory categories.

Operator actionHarm if wrong, duplicated, or abusedSuggested minimum tier
Manual ledger adjustmentUnbacked or lost balances; reconciliation breaksTier 3
Release a held withdrawalIrreversible outflow, possible sanctions or fraud exposureTier 3
Change withdrawal address allowlistRedirects future outflows to attacker-controlled destinationsTier 3
Grant or elevate admin roleDefeats every other controlTier 3
Override KYC or screening statusOnboarding or releasing a customer who should be blockedTier 2 or 3
Enable an asset or change network parametersDeposit crediting and custody exposure on a new assetTier 2
Change fee schedule or limitsRevenue leakage, market-fairness complaintsTier 2
Freeze or unfreeze an accountCustomer harm or evasion of a holdTier 2
Update support notes or labelsLow direct harm; audit trail still requiredTier 1

On a white-label or multi-tenant deployment, add a column: which tenant does this mutation touch, and can the operator see only their own? Our white-label go-live controls cover tenant safety at fund-movement level. Back-office maker-checker is the complementary operator-side layer.

How Most Teams Implement Approvals, and Why It Fails Under Scrutiny

Key takeaway: Most approval workflows verify that someone said yes. Few can prove what they said yes to, that it executed once, and that it executed unchanged.

The usual evolution is predictable. Early on, a handful of trusted engineers have direct database access. After a near miss, the team adds an admin console with roles. After an audit finding, it adds an approval step, typically a ticket in the workflow tool with a second person's comment. Each step feels like progress, and each leaves a seam.

Four common approval models compared

ModelWhat the checker actually approvesEdit-after-approval riskDuplicate-execution riskAudit evidence qualityBuild effort
1. Ticket-reference approvalA ticket ID and a descriptionHigh: execution reads current data, not approved dataHigh: retries are manual and unmanagedWeak: narrative, not proofLow
2. Role-based single stepNothing; a role permits the actionNot applicable: no second partyMediumWeak for consequential actionsLow
3. Payload-bound maker-checkerA rendered view of canonical payload, bound by hashLow: any change invalidates approvalLow if claimed atomically with target-side idempotencyStrong: request, approval, execution chainMedium
4. Payload-bound with signed step-up approvalSame as 3, plus a signed assertion from the checker's authenticator over the hashLow, and harder to forge server-sideSame as 3Strongest: non-repudiation-oriented evidenceMedium to high

No model is universally right. Model 1 can be acceptable for Tier 1 actions. For Tier 3 actions, we would treat Model 3 as the floor and consider Model 4, especially where the approval is the only thing standing between a single compromised session and an irreversible outflow.

Why the seams persist

  • The approval and the execution live in different systems. The workflow tool owns "approved", the console owns "executed", and nothing links them cryptographically or even transactionally.
  • Role union. A person holds Maker via one group and Checker via another, and the console only checks "has Checker role", not "is not the maker of this operation".
  • Timeouts handled by humans. The console shows a spinner, then an error. The operator retries. Nothing checks whether the first attempt landed.
  • Approvals never expire. A Tuesday approval gets executed the following month under different conditions.

For the reliability side of the same problem, see our CTO-focused idempotent withdrawals and webhooks design. This article applies the same principles to the operator control plane.

A Proposed Design: Payload-Bound Maker-Checker in Six Controls

Key takeaway: This is a proposed reference design for you to adapt and test, not a certified standard. Its core idea: an operation is an immutable, hashed, tenant-scoped record that moves through a small state machine, and only the executor can finish it.

The mental map

MAKER (human or agent)   |  proposes operation: tenant_id, operation_id, action_type, payload   v OPERATION RECORD (immutable payload + payload_hash)   |  state: PENDING_APPROVAL   v CHECKER (different human, step-up authenticated)   |  reviews rendering of canonical payload, approves (operation_id, payload_hash)   v APPROVED (with expiry)   |  atomic conditional claim by EXECUTOR service identity   v CLAIMED -> EXECUTING -> SUCCEEDED | FAILED_TERMINAL | UNKNOWN_RECONCILING   |   v EVIDENCE: append-only trail forwarded to your audit sink

The six controls

  1. Classify. Every action type in your inventory maps to a tier. Tier 1 is logged. Tier 2 needs one independent checker. Tier 3 needs a checker from a different function (for example, compliance for a KYC override, finance for a ledger adjustment) and may carry a mandatory delay. Unclassified action types default to the highest tier and fail closed.
  2. Canonicalize and hash. Serialize the payload in a deterministic, versioned canonical form and compute a cryptographic hash over it. For JSON payloads, RFC 8785, the JSON Canonicalization Scheme, is one published option. Any versioned canonical form works if every component uses the same one. Once stored, the payload is immutable. An edit creates a new operation with a new hash and invalidates prior approvals.
  3. Separate identities. Maker, checker, and executor are distinct. The checker cannot be the maker of that operation, enforced on identity, not on role names. The executor is a service identity that humans cannot impersonate. Operators have no direct write path to the ledger or custody layer that bypasses the executor.
  4. Approve what is rendered. The checker's screen is generated from the stored canonical payload, not from the maker's free-text description. It displays the destination, amount, asset, tenant, and the hash (or a short fingerprint). For Tier 3, consider a step-up authentication whose challenge includes the hash, so the approval is bound to that exact content.
  5. Execute under claim. The executor atomically transitions the operation from APPROVED to CLAIMED using a conditional write, then calls the target with the same tenant-scoped operation identity. The target enforces uniqueness on that identity.
  6. Record evidence. Append request, each approval (with approver identity, time, and hash), claim, execution attempt, and terminal state to a tamper-evident trail, with ownership and retention defined (see the privacy section below).

Identity of an operation versus identity of a payload

This distinction trips up many designs. The operation identity (tenant_id plus operation_id) is created once, durably, when the maker submits the request. The payload hash describes the approved content. The two are bound at creation: if anyone resubmits the same operation identity with a different payload, reject it. Do not overwrite or "update" it.

The opposite error is equally real. Two identical adjustments of the same amount to the same account on different days are legitimate separate operations. They must carry different operation identities. If you derive the identity from payload content alone, the second legitimate adjustment will be wrongly deduplicated. Generate the identity at intent time, and use the hash to detect tampering, not to define uniqueness.

Transport-level idempotency is not enough

HTTP-layer idempotency work, such as the IETF HTTPAPI working group's Idempotency-Key header Internet-Draft, addresses repeated HTTP requests. Check the current status of the document before relying on it. Even if you adopt such a header at your API edge, it covers one transport and one hop. Your control plane also needs durable operation identity at the data layer, because workers, queues, and operators are all possible sources of repetition.

Execution Safety: Atomic Claims, Target-Side Idempotency, and Unknown Outcomes

Key takeaway: A check in application code followed by a write is a race. The claim must be a single conditional write, and the target must refuse a duplicate on its own. Unknown means "could not confirm", never "succeeded" and never "failed".

Creating an operation without silent overwrite

The maker's submission should be an insert guarded by a uniqueness constraint on the tenant-scoped identity. If the row already exists, compare hashes. A matching hash means a harmless replay of the same request. A different hash is a rejected conflict and should raise an alert. The following SQL is illustrative and dialect-dependent, not a specific product's API.

-- Illustrative schema fragment (dialect varies) CREATE UNIQUE INDEX ux_operation_identity   ON operations (tenant_id, operation_id);  -- Submission: insert only if absent INSERT INTO operations   (tenant_id, operation_id, action_type, payload_canonical,    payload_hash, maker_id, state, approval_expires_at) VALUES   (:tenant_id, :operation_id, :action_type, :payload_canonical,    :payload_hash, :maker_id, 'PENDING_APPROVAL', :expires_at) ON CONFLICT (tenant_id, operation_id) DO NOTHING;  -- If zero rows inserted: SELECT payload_hash for the same identity. -- Same hash  -> replay of the same request, return existing record. -- Different  -> reject as identity reuse with changed payload; alert.

Atomic claim against concurrent workers

-- Illustrative: exactly one worker can win this transition UPDATE operations    SET state = 'CLAIMED',        claimed_by = :worker_id,        claim_expires_at = now() + interval '5 minutes',        attempt_count = attempt_count + 1  WHERE tenant_id = :tenant_id    AND operation_id = :operation_id    AND state = 'APPROVED'    AND payload_hash = :approved_hash    AND approval_expires_at > now();  -- Proceed only if exactly one row was updated. -- Zero rows: another worker owns it, approval expired, or state changed.

The conditional WHERE is what makes this a real compare-and-swap: the database evaluates the condition and applies the write as one operation. Reading the state, comparing it in application memory, and then writing is not equivalent, because two workers can both read APPROVED before either writes. Where your data store lacks conditional writes, disclose the limitation and serialize instead, for example through a single-writer queue per tenant and account, and document the throughput and failover trade-offs.

The target must defend itself

The executor's claim protects your control plane. It does not protect the ledger if a second path, such as a retry service or a manual script, also posts. The ledger journal should carry the same tenant-scoped operation identity under a uniqueness constraint, so a duplicate posting is refused at the target. If the posting also depends on a balance precondition, require a conditional mutation at the target, such as "apply only if account version equals expected version", rather than reading the balance in the caller and writing afterward. Our ledger design guide covers the double-entry foundations this relies on.

Handling ambiguous outcomes

What the executor observedWhat it meansRequired action
Target returns success with a journal or transaction referenceCompletion confirmedRecord SUCCEEDED with the reference; verify reference exists on read-back for Tier 3
Target returns explicit, documented terminal rejectionVerified failureRecord FAILED_TERMINAL with reason code; a new attempt needs a new operation and new approval
Timeout, connection reset, or malformed responseUnknown: completion could not be confirmedSet UNKNOWN_RECONCILING. Query the authoritative record by tenant_id and operation_id. Do not re-submit first.
Reconciliation finds the posting with matching hashCompletion confirmed lateRecord SUCCEEDED; close the incident
Reconciliation finds a posting with a different hashIntegrity conflictFreeze the operation, page the owner, treat as a security incident
Reconciliation definitively finds nothing and the target supports idempotent submission on the same identitySafe to resubmit with the same identityResubmit under the original operation identity; the target's uniqueness constraint is the guard
Reconciliation itself unavailableStill unknownHold the state, alert a named owner, and block dependent operations on that account

For on-chain movements, "nothing found" is subtler: a transaction may be in a mempool, replaced, or confirmed after your lookup. Apply the playbook in our unknown withdrawal outcomes guide before concluding anything. Never re-broadcast under a new nonce on the strength of a timeout alone.

Integrations: Verified Acknowledgment, Terminal Failure, Uncertain Input, and Privacy Ownership

Key takeaway: Every system that touches an operation, from your identity provider to your SIEM to a tenant's webhook endpoint, needs an answer to four questions: what counts as verified acknowledgment, what counts as terminal failure, what do we do with uncertain input, and who owns the privacy of the data it carries.

Durable recording before acknowledgment

When an inbound signal arrives, such as an approval event from a workflow tool, a screening result from a vendor, or a signed assertion from a checker's authenticator, do not acknowledge receipt until three things are recorded together: the deduplication key, the event itself (the inbox record), and the follow-up work. Put them in one database transaction, or use a transactional outbox so that scheduling is derived from the committed record. If the process crashes between "acknowledged" and "scheduled", the sender will not retry, and the approval is silently lost. If it crashes before acknowledgment, the sender retries and the deduplication key absorbs the repeat. For outbound events, such as audit forwarding or tenant notifications, the mirror rule applies: the outbox record is created in the same transaction as the state change, and "delivered" means a verified acknowledgment from the receiver, not merely that your client library returned.

Integration matrix

IntegrationVerified acknowledgmentTerminal failureUncertain input handlingPrivacy owner (propose)
Identity provider and step-up authenticationAssertion verified server-side, tied to checker identity and the operation hashFailed or expired challenge: approval not recordedMissing, unsigned, or unparseable assertion: treat as not approvedIdentity and access owner
Workflow or chat notification to checkersDelivery receipt is informational only; approval counts only when recorded in your systemUndeliverable after defined attempts: escalate to a named on-call approverReply-by-chat approvals are ignored unless the integration is verified and hash-boundSecurity operations
Ledger serviceJournal reference returned and readable by operation identityDocumented rejection codeTimeout: UNKNOWN, reconcile before any retryFinance and platform owner
Custody or signing providerProvider-side transaction record matching operation identityProvider-declared terminal stateUnknown broadcast state: reconcile against provider and chain; no re-send under a new identityCustody owner
KYC or wallet-screening vendor status feeding an overrideAuthenticated response bound to the subject and caseVendor-declared final decisionPending, partial, or unmatched result: fail closedCompliance head
SIEM or audit sinkSink acknowledgment received and loggedDead-letter queue with an owner and age alertOut-of-order or duplicate events deduplicated by event IDSecurity and data protection owner
Tenant-facing webhooks (white-label)Tenant endpoint returns success after its own durable write, per contractExhausted retries: tenant notified through a second channelUnsigned or wrong-tenant callbacks rejectedTenant data controller as defined by contract

See also our CISO checklist on vendor callback controls for the inbound verification detail.

Tenant-safe idempotency

  • Scope every operation key by tenant. A bare operation ID that is globally unique is fine, but uniqueness and lookups must still be evaluated within the tenant, so one tenant can never collide with, observe, or replay another's operation.
  • For cross-tenant lookups, return "not found" rather than "exists but forbidden". The distinction itself leaks information.
  • Evaluate approver eligibility per tenant. A checker approved for Tenant A is not automatically a checker for Tenant B.

Privacy ownership of the approval trail

Maker-checker generates a record of exactly what is sensitive: destinations, amounts, user references, and free-text justifications. Treat identifiers as potentially sensitive data. Wallet addresses, user IDs, and KYC notes can be personal data depending on context and jurisdiction, so your counsel and data protection function should decide what applies to you. Practical consequences include:

  • Minimize in the trail. Store references and the hash in the broadly readable log. Keep full payloads in a restricted store with access logging.
  • Be careful with plain hashes. A plain hash of a low-entropy value, such as a small set of user IDs, can be recovered by guessing. Where hashes leave the trusted boundary, consider a keyed hash with the key held in your key management service.
  • Name an owner. Someone is accountable for retention periods, legal-hold handling, access reviews, and deletion requests. Retention for audit evidence and deletion obligations can conflict, and resolving that is a legal and compliance decision, not an engineering default.
  • Restrict free text. Free-text justification fields tend to collect personal data nobody planned for. Prefer structured reason codes plus a reference to the case system.

Why This Fails in the Real World

Key takeaway: Capable teams fail here because of system and governance gaps: approvals designed as paperwork, exceptions that become the default path, and no one owning the seam between workflow and execution. The scenarios below are illustrative composites of common patterns, not reports about a specific client.

Pattern 1: The approved amount that was not the executed amount

A support lead raises a manual adjustment and writes a clear description. A finance checker approves the ticket. Before execution, the maker notices a typo and edits the amount in the console, because the console reads from the live form, not the approved record. The checker's approval now covers content that never existed in front of them. Nobody acted in bad faith. The system allowed a mutable object behind an immutable-looking approval. The fix is structural: the payload is immutable once submitted, the approval names the hash, and the executor refuses to run if the hash differs.

Pattern 2: The retry that doubled a credit

An executor calls the ledger and the call times out. The console shows an error. The operator, under pressure from a customer escalation, clicks Retry. The first call had landed. The customer now has two credits, discovered days later in reconciliation. Intelligent teams fail here because the retry button feels like a safe default. In a consequential mutation, it is a second mutation. The fix is the unknown-outcome rule: timeouts move the operation to a reconciling state, lookup by operation identity comes first, and the ledger enforces uniqueness on that identity.

Pattern 3: Break-glass as the main entrance

The team creates an emergency path for incidents at 3 a.m. It works well and becomes the way to skip the approval queue whenever the queue is slow. Within months, a large share of Tier 3 actions flow through it. The control exists on paper while the exception carries real volume. Governance gap: no one measures exception rate, and no one owns the cause of queue latency. The fix is to treat break-glass usage as a monitored metric with review requirements, and to fix on-call approver coverage so the exception stays rare.

Pattern 4: Two roles, one person

A small team grants the same senior engineer both the Maker and Checker roles "for coverage". The console checks that the approver holds the Checker role. It does not check that the approver differs from the maker of this operation. A single person can now complete the whole loop. Role-based access control without a per-operation distinctness check is a classic segregation-of-duties gap, and ISO/IEC 27002 specifically cautions about granting conflicting roles in RBAC systems and using automated tooling to detect conflicts when roles are numerous.

Pattern 5: The lost approval

A workflow tool sends an approval event to your platform. The platform returns success immediately, then enqueues work in a separate step. The process restarts in between. The sender believes delivery succeeded, so it never retries, and the operation sits approved in one system and pending in another. Weeks later it executes after a manual "sync". The fix is atomic recording of the event, its deduplication key, and the scheduled work before acknowledgment, or an explicitly recoverable outbox with reconciliation.

Failure patternUnderlying gapControl that closes it
Edit after approvalMutable payload behind approvalImmutable payload, hash-bound approval
Retry doubles effectAmbiguous timeout treated as failureReconcile first, target-side uniqueness
Break-glass normalizationNo exception metrics or ownerMonitored exception rate with review
Maker equals checkerRole check without identity checkPer-operation distinctness enforced server-side
Lost approval eventAcknowledgment before durable recordAtomic inbox, dedupe, and scheduling

Go/No-Go Controls, Trade-offs, and a Lower-Risk Rollout

Key takeaway: Treat the checklist below as all-required for any mutation class you place in Tier 2 or Tier 3. A single "no" blocks go-live for that class. There is no summed score, and passing every item is necessary but does not certify your platform as compliant or secure.

Mandatory go/no-go checklist

#Control (all required)Test you can runResult
1Every operator mutation type is inventoried and tiered; unclassified defaults to highest tierAdd an unknown action type in staging; confirm it demands Tier 3 approvalGo / No-go
2Payload is immutable and hashed in a versioned canonical formAttempt to alter a stored payload by API and by database role; both must fail or invalidate approvalGo / No-go
3Approval names (tenant_id, operation_id, payload_hash) and expiresExecute after expiry; confirm refusalGo / No-go
4Maker cannot approve own operation, regardless of roles heldGive one test user both roles; confirm self-approval is rejectedGo / No-go
5Checker sees the rendering of stored canonical payload, not maker-supplied textMake description and payload disagree; confirm checker UI shows the payloadGo / No-go
6Reuse of an operation identity with a different payload is rejected and alertedReplay with changed amountGo / No-go
7Claim is a single conditional write; concurrent workers cannot both proceedRun parallel executors under load; confirm one effectGo / No-go
8Target (ledger, custody) enforces the same tenant-scoped operation identityBypass the control plane with a duplicate call; target must refuseGo / No-go
9Timeouts produce UNKNOWN_RECONCILING, never automatic blind retryInject timeout after target success; confirm reconciliation finds it, no second effectGo / No-go
10Identical later operations with new identities are permittedSubmit the same adjustment on a second day; confirm it is not deduplicatedGo / No-go
11Inbound events: dedupe, record, and schedule are atomic or recoverable before acknowledgmentKill the process between steps; confirm no lost or duplicate workGo / No-go
12Humans have no direct write path around the executor; privileged access is time-boxed and recordedReview database and cloud IAM; attempt out-of-band postingGo / No-go
13Break-glass is pre-registered, alerting, and reviewed; its rate is monitoredTrigger it; confirm alert and mandatory reviewGo / No-go
14Evidence trail is append-only or tamper-evident, with a named privacy and retention ownerSample five operations end to end; produce request, approval, execution, outcomeGo / No-go

For recurring evidence collection across all your controls, our continuous compliance checklist shows how to keep this from becoming a once-a-year scramble.

Risks, constraints, and trade-offs

  • Latency versus assurance. Approvals slow urgent fixes. Mitigate with tiering, staffed approver rotas, and pre-approved templates for routine Tier 2 actions, not with exceptions.
  • Approver fatigue. If everything is Tier 3, checkers rubber-stamp. A smaller, well-chosen Tier 3 list produces more genuine review.
  • Small teams. Where true segregation is impractical, ISO/IEC 27002 points toward compensating controls such as monitoring, audit trails, and management supervision. Document the compromise, and do not pretend it is full separation.
  • Collusion. Two cooperating insiders can still approve a bad payload. Cross-functional checkers, delays on Tier 3, anomaly monitoring, and periodic sampling reduce but do not eliminate this.
  • Signed approvals add complexity. Step-up signing over the hash improves evidence but requires authenticator management and recovery processes. Adopt it where the risk justifies the operational cost.
  • Not a legal conclusion. Regulators and auditors in your jurisdictions set their own expectations. The FATF's virtual assets work is a useful global reference for risk-based expectations on service providers, but whether this design satisfies a specific licensing or audit requirement is for you and your advisers to determine.

A lower-risk rollout path

  1. Observe first. Route all operator mutations through the operation record in log-only mode for a few weeks. Learn the real action volume and timing before enforcing.
  2. Enforce Tier 3 on the smallest set. Start with role grants, allowlist changes, and manual ledger adjustments. These are rare, high-impact, and easy to defend.
  3. Close the bypasses. Remove direct database and script access to the mutation path. A control with a side door is a suggestion.
  4. Add target-side idempotency. Make the ledger and custody integrations enforce operation identity, then run the timeout and duplicate injection tests.
  5. Expand to Tier 2 and tune. Review exception, expiry, and rejection rates monthly.

2027 Update: what to re-verify, and what stays constant

For 2027 planning, two things deserve a fresh look, and both are framed so they stay valid beyond any single year. First, automation and AI agents as makers. Teams increasingly let scripts or agent tooling propose operator actions. Treat any non-human identity as a maker only, never a checker, require human approval for Tier 2 and above, and give it its own scoped, auditable identity. Second, standards and guidance revisions. Re-check the current editions of NIST SP 800-53, ISO/IEC 27001 and 27002, and the HTTP idempotency work referenced above, along with your regulators' guidance, at least annually. The underlying principles, which are separation of duties, immutable approved content, atomic claims, and reconciliation of unknowns, have been stable for a long time and are what auditors keep testing.

Could one compromised operator session move value on your platform?

If you cannot prove otherwise with a test, that is your answer. Let's find out before an auditor or an attacker does.

Ask Errna's security and exchange engineers to review your back-office mutation paths.

Contact Us

Conclusion: Five Actions for Your Next Security Review

Maker-checker is not a screen with two buttons. It is a design in which approved content cannot change, work executes once, and unknowns are reconciled instead of guessed. Here is what to do next, in order.

  1. Build the mutation register this month. List every operator action that moves value, changes a control, or alters a customer's status, assign a tier, and default unknowns to the highest tier.
  2. Test the three failure modes first: edit after approval, maker equals checker, and timeout followed by retry. If any one succeeds in staging, mark that mutation class no-go.
  3. Verify the target, not just the console. Confirm the ledger and custody layers enforce tenant-scoped operation identity and conditional mutations, or document the serialization limits you rely on instead.
  4. Name owners. Assign a person for exception review, for the evidence trail's privacy and retention decisions, and for on-call approver coverage.
  5. Schedule recurring evidence. Sample operations end to end each quarter and review break-glass usage, so audit readiness is a habit rather than a project.

For adjacent controls, see our guides on multi-signature architecture for key-level approval and on Errna's blockchain security audit and crypto compliance services pages if you want an outside review of your controls.

About the Errna team

Errna is a blockchain and digital asset technology company, founded in 2003, with 1000+ in-house professionals building exchange software, custom blockchain systems, and compliance-oriented infrastructure for clients in 100+ countries. Errna reports ISO 27001 and CMMI-aligned delivery processes and SOC 2 accreditation for its own organization. Those statements describe Errna's delivery practices. They do not confer certification or compliance on any platform you operate. The design in this article is a proposal for your team to adapt and test, and it is not legal or regulatory advice.

Reviewed by Errna Expert Team.

Frequently Asked Questions

What is a maker-checker control on a crypto exchange?

It is a control where one authenticated party (the maker) proposes a consequential operation, a different authenticated party (the checker) approves it, and a separate execution service performs it. For exchange back offices, the approval should bind to the exact payload by hash, so that changed content cannot ride on an old approval.

Is a ticket approval in a workflow tool enough for a manual ledger adjustment?

Usually not for consequential adjustments. A ticket approval proves someone agreed to a description. It does not prove that the executed amount, account, and tenant match what was reviewed. Bind the approval to an immutable payload hash and have the executor verify it before running.

What should we do when an adjustment or withdrawal call times out?

  • Mark the operation as unknown, meaning completion could not be confirmed.
  • Look up the authoritative record by tenant-scoped operation identity.
  • Resubmit only if the target definitively shows nothing and enforces uniqueness on the same identity.
  • If reconciliation is unavailable, keep the unknown state, alert an owner, and block dependent actions.

How do we avoid blocking legitimate repeat operations when we deduplicate?

Generate the operation identity when the operator expresses intent, not from payload content. Two identical adjustments on different days then carry different identities and both proceed. Use the payload hash only to detect changed content under a reused identity, which you reject.

Is a database read-then-update enough to claim an approved operation?

No. Two workers can read the same state before either writes. Use a single conditional write, such as an update that requires the state to be APPROVED and the hash to match, and proceed only if exactly one row changed. If your store cannot do that, serialize work and disclose the limits.

Do wallet addresses and user IDs in approval records count as sensitive data?

They can. Depending on context and jurisdiction, identifiers such as wallet addresses, user IDs, and KYC notes may be personal data. Minimize what the broadly readable audit log stores, restrict full payloads, use keyed hashes where hashes leave your boundary, and have your legal and data protection advisers set retention and deletion rules.

Does implementing this design make us compliant or audit-ready?

No design alone does. The go/no-go checklist is a set of necessary tests for the mutation classes it covers. Compliance depends on your jurisdictions, licenses, and auditors' requirements, along with how the controls operate over time with evidence. Treat the checklist as one input to that broader assessment.

Can an AI agent act as a checker?

We would not recommend it for Tier 2 or Tier 3 mutations. Treat agents and scripts as makers with their own scoped, auditable identities, and require an independent human checker for consequential actions. This is a design recommendation, not a regulatory requirement.

Your exchange's weakest control may be a button, not a firewall.

Payload-bound approvals, atomic execution, and reconciled outcomes are buildable. The sooner you test them, the cheaper the findings.

Talk to Errna about hardening your exchange back office, ledger integrations, and audit evidence, whether you build, white-label, or operate a SaaS platform.

Contact Us

Explore related services: crypto exchange development, white-label crypto exchange, and blockchain security audit.