Product development / Crypto Exchange Development
Crypto Exchange Development with clear scope, control and acceptance.
Scope the matching engine, durable ledger, custody, liquidity, trading clients and operator controls together. Test recovery and reconcile assets and liabilities before a venue handles funds.
Discuss your project โContents ยท Crypto Exchange Development
Start with control and recoverable state.
This service scope keeps the original workflow and capability depth as requirements to inspect, agree and test. It does not assert available ready-made inventory, assigned staff, completed projects, customer outcomes, registration, commercial terms or a functioning backend.
Matching and accounting
Separate order matching from account balances, but define a durable transaction boundary joining accepted orders, reservations, fills, fees and ledger effects. An in-memory order book and a balanced posting are not, by themselves, crash recovery or replay safety.
Custody architecture
Set operational hot-wallet exposure, cold-storage policy, signing thresholds and replenishment approvals from the actual risk model. Inspect who can change the policy as well as who can sign; an HSM or multisig label does not remove every unilateral path.
Identity and monitoring
Scope identity tiers, sanctions screening, transaction-monitoring rules, review queues and evidence retention with the operator and qualified advisers. Provider integration supplies controls, not the legal right to operate.
Withdrawals
Define allowlisting and address-change holds, velocity limits, approval thresholds, authorization, durable request IDs and chain-specific broadcast tracking. Exercise retries, rejected requests, stuck transactions and approval-policy changes.
Measured workload
Use representative books, order sizes, cancellation bursts, market states and chain/provider failures. Measure accepted, matched, posted and acknowledged states separately, with correctness and recovery evidence alongside throughput.
Set the implementation boundaries.
Inspected starting point
Inspect the exact proposed module version, dependencies, licence and missing functions before choosing reuse. Agree scope and milestones from evidence, not advertised prices or launch intervals.
Asset and chain matrix
Select Bitcoin and each EVM network explicitly, including Ethereum, BNB Chain, Polygon, Arbitrum or Base only where required. Confirm token behavior, confirmation policy, RPC/indexing and withdrawal support per target.
Independent review scope
Agree architecture, application, signing, infrastructure and operational review boundaries. Internal test reports are not an independent penetration-test result or regulator approval.
Trading products
Choose spot, margin, futures, P2P, OTC and custody as distinct products. Derivatives require explicit collateral, funding, liquidation, default and market-integrity rules; spot code does not establish these.
Catalogue alternatives
Compare an inspected exchange-style base with custom work through the same ledger, custody and acceptance scenarios. A named catalogue entry is not proof of available working stock.
Rights and exit
Agree custom code, reusable-component licences, account ownership, source history and operational handover. Rehearse a receiving-team build and ledger recovery.
Workflow categories to inspect, not claimed deployments.
The inherited reference brands identify workflow categories only. They do not establish affiliation, verified stock, rights to competitor assets or a delivered customer project.
Multi-currency account workflow
Inspect fiat balances, card/transfer provider boundaries, FX quote expiry, reserved funds, ledger entries and reconciliation. A banking-style interface is not a banking authorization.
Cross-border transfer workflow
Define source/destination currencies, provider quote validity, fees, beneficiary checks, corridor availability, failed transfers and returned funds. Software cannot guarantee provider settlement or licensing.
P2P exchange workflow
Scope offers, asset escrow, payment evidence, timers, disputes, release authority and fraud review. A fiat-payment screenshot is not proof of irrevocable receipt.
Perpetual or leveraged trading workflow
Specify pricing/oracles, collateral, margin, funding, liquidation, insurance/default handling and operator powers. Inspect actual liquidity and legal eligibility rather than inherit another venue's brand or risk assumptions.
Token-launch workflow
Define eligibility, allocation, caps, fund custody, vesting, refunds, disclosures and contract authority. A launchpad interface does not establish investment eligibility or permitted distribution.
Centralized exchange workflow
Review order entry, matching, fees, balance reservations, deposits, withdrawals, risk limits and administration end to end. Establish the exact implementation and rights before using an exchange-style base.
Compare actual rights, control and evidence.
On smaller screens, scroll the table sideways to read every column.
| Decision | Centralized exchange | Decentralized exchange design | Hybrid design |
|---|---|---|---|
| Control | Operator book/ledger and any custody need explicit safeguards. | Inspect contracts, escrow, routers, admin keys and user powers. | Map each on-chain and operator-controlled boundary. |
| Settlement | Separate internal fills from external deposits/withdrawals. | Determine what is on-chain, batched, escrowed or externally matched. | Specify reconciliation and finality across both sides. |
| Liquidity and cost | Contract actual makers/routes, inventory, limits and fees. | Inspect actual pools/order flow, fees, slippage and failure risk. | Specify source selection, conflicts and disconnect behavior. |
| Assessment | Test matching, accounting, custody and recovery. | Test contract/economic rules, authority and dependencies. | Test complete state, money and authority transitions. |
| Legal and fit | Review actual operator activities and markets with advisers. | A decentralized label does not settle legal obligations. | Review each activity and responsibility, not the label. |
Compare the same representative success, denial, failure and recovery scenario. No route guarantees security, legal eligibility, low cost or fast delivery.
Detailed project and buying questions.
CEX, DEX, P2P or OTC - which kind of crypto exchange should you build?
A centralized venue controls an internal book and ledger and may custody assets. A DEX depends on its actual contracts, escrow, routers, admin keys and settlement design; not every operation or order is necessarily on-chain. P2P adds counterparty payment and dispute risk. OTC adds quotes, credit and post-trade settlement. Choose the control model before choosing a familiar interface.
What does a centralized crypto exchange build include?
Define order entry and cancellation, price/size filters, matching priority, locked and available balances, durable fills, fees, asset custody and client/admin interfaces. Market, limit and stop orders have different validation and execution rules. Add collateral and liquidation only with separate product rules. Acceptance must include restart, concurrency and reconciliation, not only a successful trade.
Do you need a licence to run a crypto exchange, and who holds it?
The operator and appropriately qualified advisers must establish permissions for each activity, customer group and operating market. Exchange, custody, fiat rails, derivatives and token distribution are not interchangeable legal categories. Record licences or partner arrangements, permitted assets, restrictions and reporting responsibilities. Software delivery and KYC integration do not establish authorization.
How is custody protected on a new crypto exchange?
Build a custody control map covering deposits, confirmations, replenishment, withdrawal requests, approvals, signing, broadcast and recovery. Separate signer authorization from app login, protect key backups and constrain policy changes. Reconcile holdings and liabilities per asset. Test compromise and unavailability scenarios; a penetration test does not prove reserves or future safety.
How fast can a crypto exchange go live?
Build milestones only after inspecting existing code, trading rules, provider contracts, legal dependencies and acceptance evidence. Separate engineering readiness from legal permission, liquidity onboarding, bank/PSP access, independent assessment and store review. Do not open to customers because a source page advertises a build interval.
Where does liquidity come from on a new exchange?
Liquidity can come from independent market makers, customer orders or explicitly contracted external routing. Specify inventory/credit, API permissions, cancellation and disconnect behavior, stale-quote limits, fees, reporting and conflicts. Do not represent simulated depth as available liquidity, fabricate volume or treat a connector as a funded commercial relationship.
What does it cost to build and run a crypto exchange?
Budget matching and ledger work, custody, chain scanning, trading clients, compliance integrations, reporting, test/review and handover separately. Ongoing costs include nodes/RPC, monitoring, providers, assessment, incident coverage and liquidity arrangements. Request a current itemized written quote. No catalogue amount or recurring support offer is established here.
Detailed checklist 1
- Matching: define priority, order types, sequencing, cancellation and deterministic replay; isolate resource pressure without losing durable order/fill state.
- Ledger: use explicit asset units and balanced entries, durable reservations, fees and reversal records; reconcile per asset against controlled holdings and external obligations.
- Custody: set hot/cold exposure, signing and recovery policy; implement per-chain scanners, confirmation thresholds and reorganization handling.
- Identity: integrate the operator-selected provider with tiering, sanctions/monitoring decisions, manual review and access-controlled evidence retention.
- Liquidity: agree commercial counterparties, credential permissions, quote/route rules, limits, fees and disconnect behavior before activating connectors.
- Administration and risk: test listing, fee, withdrawal and position-limit changes with authorization, approvals and an attributable audit trail.
Detailed checklist 2
- Hot-wallet exposure and cold replenishment require written operating limits, approval rules and reconciliation.
- HSM or multisig deployment needs verified participants, thresholds, recovery paths and policy-change controls; no secrets belong in source control.
- Withdrawal retries require durable deduplication and transaction-state tracking alongside allowlists, velocity limits and holds; a request key alone is not enough.
- Sensitive fund movements and limit changes need explicit separate approval where agreed, with emergency exceptions recorded and tested.
- Agree independent reviewer scope, evidence, remediation and retest before relying on a review; preparation is not completion.
Architecture and failure boundaries.
Matching engine and durable ledger
Design order intake, sequencing, reservations, fills, fees and book updates as one recoverable workflow. The ledger is the accounting record, while snapshots and durable events must permit a consistent book rebuild. Commit boundaries, outbox/inbox processing and deduplication need explicit tests for crashes between each step.
Custody and withdrawal boundary
Keep signer permissions outside ordinary admin sessions; authorize amount, asset, destination and network deliberately. Track requested, approved, signed, broadcast, confirmed, replaced and failed withdrawals. Deposit credits need chain identity and finality/reorganization policy. Reversing an accounting record cannot reverse a confirmed external transfer.
Simulation, failures and reconciliation
Replay deterministic order sequences and adversarial rounding, concurrency and restart cases. Measure realistic depth and load without inventing latency guarantees. Compare ledger liabilities, reservations, custody assets, external balances and fees per asset, with documented pending items and an owned exception queue.
The original technical example and its limits.
Illustrative code. Review its missing dependencies and implementation boundaries before using it in a product.
Scroll the code sideways on smaller screens to read each complete line.
import { OrderBook, type Order, type Fill } from './book';
import { Ledger } from './ledger';
const minQty = (a: bigint, b: bigint): bigint => (a < b ? a : b);
const crosses = (taker: Order, maker: Order): boolean =>
taker.side === 'buy' ? taker.price >= maker.price : taker.price <= maker.price;
export class MatchingEngine {
constructor(private readonly book: OrderBook, private readonly ledger: Ledger) {}
submit(order: Order): Fill[] {
const fills: Fill[] = [];
let remaining = order.remaining; // integer minor units, never floats
while (remaining > 0n) {
const best = this.book.bestOpposite(order.side);
if (!best || !crosses(order, best)) break;
const qty = minQty(remaining, best.remaining);
fills.push(this.settle(order, best, qty));
this.book.reduce(best.id, qty); // removes the maker once filled
remaining -= qty;
}
if (remaining > 0n) this.book.rest({ ...order, remaining });
return fills;
}
private settle(taker: Order, maker: Order, qty: bigint): Fill {
const quote = (qty * maker.price) / this.book.baseUnit;
const [buyer, seller] = taker.side === 'buy' ? [taker, maker] : [maker, taker];
this.ledger.post([
{ account: seller.account, asset: this.book.base, amount: -qty },
{ account: buyer.account, asset: this.book.base, amount: qty },
{ account: buyer.account, asset: this.book.quote, amount: -quote },
{ account: seller.account, asset: this.book.quote, amount: quote },
]);
return { price: maker.price, qty, makerId: maker.id, takerId: taker.id };
}
}What the sample actually does
The snippet loops over the best opposite order, chooses the smaller quantity, calculates quote units with bigint integer division and calls Ledger.post with four entries. It imports OrderBook, Order, Fill and Ledger without their implementations. Atomic posting, priority and balance enforcement therefore cannot be verified from this example.
Atomic ledger posting is not atomic matching
Ledger.post precedes book.reduce and rest. A crash or retry between them can repeat accounting or leave book and ledger states inconsistent unless the missing components provide durable sequencing, deduplication and recovery. The snippet does not show a shared transaction, event log, durable order ID or restart protocol.
Missing order and financial rules
No positive quantity/price validation, asset-unit validation, available-balance reservation, self-trade policy, order-type handling, fees, cancel handling or concurrency control is visible. Integer division truncates quote amounts; tiny fills can round to zero. Specify minimum notional and rounding/accounting treatment and test adversarial splits.
Not a complete exchange
The snippet contains no deposit scanner, custody signer, KYC, risk engine, withdrawal state machine or reconciliation implementation. Balanced rows per asset do not prove solvency, available funds or legally permitted operation. Keep this as a small illustrative matching loop, not deployable trading software.
Three engagement routes to agree in writing.
Inspect and adapt a starting point
Actual inventory
Inspect the proposed version, role paths, app/backend/admin surfaces, tests, data model, dependencies and unresolved gaps. A catalogue name or screenshot does not establish working inventory.
Scope boundaries
Write the retained functions, changed rules, missing services and exclusions. Separate branding from custody, financial, identity, tenancy and core-flow changes.
Integration and accounts
Identify authorized customer/provider accounts, sandbox/live approval, access scopes and credentials. Connecting an API is not permission to move money or publish for another business.
Acceptance and release
Test the assembled release and its configuration against the actual failure, privacy, performance and recovery requirements. Require owner readiness and any independent assessment before production.
Rights and receiving team
Agree custom/reusable/third-party rights, source history, deployment and ongoing responsibility. Have the receiving team reproduce the essential build and recovery steps.
Build the specified product
Written specification
Define roles, workflows, assets/data, state transitions, provider dependencies and failure/recovery behavior with acceptance and change control.
Architecture
Decide state ownership, authorization, payment/signing and tenant boundaries. Choose actual components and deployment targets from the scope rather than a marketing stack.
Reviewable increments
Require reviewable commits, meaningful tests and demonstrations of success, denied and failed paths. Agree a practical milestone and communication plan, not an unsupported recurring-demo promise.
Release responsibilities
Name who authorizes production, owns stores/domains/infrastructure and responds to incidents. External legal, provider and store approval remain distinct from engineering completion.
Handover
Deliver reproducible source, dependency licences, tests, schema/migrations, configuration names, runbooks and supported account transfers. Do not put private keys or production credentials into ordinary documents.
Continue engineering and operation
Actual commercial terms
Agree capacity, billing, notice, support, response versus repair commitments and exit in the signed contract. No source-page retainer or cancellation interval is adopted.
Owned responsibilities
Name implementers, reviewers, responders and release decision-makers for the actual engagement. A service description is not a claim of assigned staff.
Maintenance scope
Separate new workflows, provider/API changes, operating services, dependency/security updates and defect repair. Retain approval boundaries for funded services and live financial actions.
Change evidence
Keep scope, commit, tests, assessment needs, migration and rollback/recovery evidence for each increment. Small configuration changes can alter money movement or client isolation.
Continuity
Maintain runbooks, access inventory, alert ownership and safe offboarding as the scope changes. Test the receiving team's ability to keep operating without temporary supplier access.
Source-specific security and quality acceptance.
Hot/cold exposure
Test configured hot-wallet limits, replenishment, cold access and incident shutdown, including stale data and unavailable approvers.
Cold-storage approvals
Verify threshold enforcement and change controls, key backup and recovery; test whether any alternate signer/admin path bypasses the policy.
Order-book correctness and load
Exercise fills, cancellations, partials, bursts, disconnects, restart/replay and concurrency. Record correctness and resource metrics for the agreed workload.
Analysis and dependencies
Review static findings, unsafe arithmetic, injection, authorization and dependency advisories with ownership and remediation evidence.
Privileged governance
Test sensitive admin and limit changes against the role/approval matrix, including emergency access and an attributable audit trail.
Withdrawal policy
Test destination changes, holds, limits, approvals, duplicates, broadcast uncertainty and reorganization/finality behavior for each asset/network.
Independent assessment evidence
Prepare architecture, threat model, test traces and release configuration for the selected reviewer. Separate prepared, assessed, remediated and retested states.
Original nested quality gates, with testable boundaries.
Static and dependency review
Preserve tool versions, detector results and human triage for injection, authorization, unsafe integer/asset-unit handling and dependency advisories. Unresolved findings need explicit ownership and release disposition.
Stateful failure and fuzz tests
Exercise order, cancellation, reserve, fill and withdrawal paths with boundary/adversarial values, repeated messages and forced failures between durable steps. Preserve counterexamples and prove replay does not duplicate accounting or external transfers.
Accounting and custody invariants
Check balanced entries per asset/currency, valid units and rounding, available/reserved balances and fee accounting. Reconcile liabilities and controlled assets with documented pending transactions, receivables and other obligations; do not force a naive equality or treat a balanced ledger as solvency evidence.
Representative load
Record depth, order mix, cancels, concurrent accounts, failures and hardware/configuration when measuring accepted/matched/posted/acknowledged states. Local results do not guarantee production latency or external settlement.
Withdrawal approval and hold policy
Test multi-approver thresholds, holds, address/limit changes, emergency exceptions, cold replenishment and all alternate signer paths. An idempotency key alone cannot prevent every double payment.
Independent review package
Deliver architecture, threat model, dependencies, test traces, signer/custody map, deploy/recovery runbooks and the frozen candidate. Record review, fixes and retest separately from preparation.
Monitoring and incident ownership
Define deposit/scanner lag, withdrawal queue, hot-wallet exposure, reconciliation exceptions and alert routing with named responders and tested shutdown/recovery. Agree actual coverage and support term rather than inherit a fixed watch window.
Release, recovery and receiving-team gates.
Review and change control
Require traceable review of application, API, configuration and migration changes. Inspect authorization, business rules, dependencies and error handling together. Agree which checks block merge and how an exception is approved and recorded.
Automated and end-to-end tests
Cover domain rules, data boundaries and the critical user paths with unit, integration and end-to-end tests. Include denied actions, retries, expired sessions and partial failures. Set meaningful coverage and acceptance criteria for the actual scope rather than treating a percentage as proof.
Release-build performance
Measure the production configuration with representative devices, browsers, network conditions and realistic data. Record cold and repeat loads, slow operations and resource use against written budgets. Keep the observations and unresolved limitations with the release.
Security and privacy
Check server-side authorization, secret handling, dependencies, logging and the exposed attack surface. Keep private data out of client bundles, analytics and diagnostics. An automated scan or encryption setting is not a complete security assessment or a compliance certificate.
Release and recovery
Rehearse deployment, schema changes, backup restoration and rollback. Verify the domain, TLS, environment settings and provider configuration. For mobile scope, inspect signing, privacy disclosures and store-submission responsibilities without promising approval.
Handover and operation
Test the receiving team's access, build and recovery instructions. Verify monitoring, alert routing, support terms and the defect register. Record accepted limitations and follow-up owners before calling the release accepted.
The full original tool inventory, subject to selection.
Historical version labels remain identified as such, not current recommendations. Verify maintained releases, advisories, licences, compatibility, privacy and recurring charges for the actual product.
Go / TypeScript
Engine/API language options. Define numeric units, concurrency, ordering and durable error/recovery behavior; type safety is not accounting correctness. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
PostgreSQL
Relational persistence option for ledger and operational state. Test transaction isolation, constraints, backups and replay/reconciliation. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
Redis
Cache/queue option. Decide which state is disposable and which requires durable authoritative storage; test eviction, restart and duplicate jobs. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
Kafka
Event-stream option. Define partition ordering, durable offsets, replay and consumer deduplication; transport semantics are not end-to-end exactly-once money movement. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
WebSocket
Live price/order-state transport. Design authentication, reconnect, snapshots, sequencing and stale-state indicators. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
Bitcoin Core
Bitcoin node route. Pin version/configuration and test UTXO, confirmation, reorganization, fee and node-recovery behavior. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
EVM nodes / RPC
Chain-access route. Validate chain identity, supported methods, limits, finality/reorgs, indexing and provider failover. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
HSM / Multi-sig
Different signing/control options. Verify actual key/share holders, thresholds, policy changes, backup and recovery, including bypass paths. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
KYC / AML
Provider and policy integration categories, not certificates. Define permitted activity, risk tiers, review, evidence retention and accountable operator decisions. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
TradingView
Charting integration option. Verify actual library/data licence, supported features, data provenance, attribution and current commercial terms. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
TypeScript
Typed application language. Validate API/RPC input and financial units at runtime, model state transitions and retain regression tests. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
React / Next.js
Trading/dashboard frontend options. Define server/client boundaries, sensitive-data exposure, cache freshness and transaction/authentication states. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
Flutter
Mobile UI option. Pin a maintained toolchain and test selected devices, platform services, store requirements and payment/wallet flows. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
Docker
Service packaging. Pin images, keep secrets outside images and test persistent data, restart, migration and recovery. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
Grafana
Metrics/dashboard/alerting option. Define source metrics, permissions, alert delivery, responder coverage and retention; a dashboard is not an operating team. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
Penetration test
An assessment activity, not a deployed technology. Agree independent scope, candidate version, evidence, findings, remediation and retest. Select only what the inspected scope needs; no configured account, paid service or assigned specialist is implied.
From brief to an evidence-based release.
Brief and confidentiality
Describe users, the core workflow, existing systems, sensitive data and business constraints. Agree confidentiality and information-sharing boundaries before handing over restricted material.
Scope and plan
Choose the build route and inspect any proposed existing base. Write the role matrix, architecture, integration contracts, exclusions, acceptance tests, dependencies and milestone plan with an itemized quote.
Build and review
Use version control, repeatable environments and checks suitable for the project. Review working increments against the agreed workflow, including loading, empty, denied and failure states. Track scope changes explicitly.
QA and release decision
Run the agreed functional, integration, accessibility, security and performance checks against the release build. Rehearse migration and recovery, preserve evidence and decide which issues block launch.
Launch and handover
Release through authorized accounts with a tested recovery path. Deliver source, documents and operating access, confirm monitoring and support ownership, and have the receiving team demonstrate the essential operations.
External dependencies and timing
Legal and provider decisions, independent assessment, eligible account verification and app-store review have their own requirements. Agree dates from inspected scope and current dependencies; no inherited guaranteed launch, instant NDA or first-commit interval is adopted.
Build a scope-based budget and real commercial terms.
Reuse and integration
Delivered surfaces
List every app, web client, extension, API, admin console, schema and integration actually supplied.
Inspection and adaptations
Quote version/licence inspection, required differences, migrations and regression work separately.
Branding and content
Use permitted assets and content; include notifications, domains, errors, deep links and store listings where relevant.
Acceptance evidence
Price real-device/browser, failure, security/privacy and recovery checks with clear test environments and evidence.
Operation
Separate hosting, providers, custody/signing, monitoring, incident coverage and ongoing patches with actual accountable owners.
Confidentiality and rights
Agree restricted disclosure, source/asset access, custom assignment and reusable/third-party licences in writing.
Custom implementation
Roles and responsibilities
Itemize app, backend, ledger/signing, data, QA, review and operating work required; do not imply a preassigned team.
Rules and dependencies
Count state machines, provider integrations, chain families, tenant/client variants and migration needs.
Review and assessment
Define internal tests, independent assessment/remediation, acceptance and residual-risk decisions for the actual candidate.
Release work
Include supported build/signing, infrastructure configuration, provider/store coordination and recovery rehearsal without promising approval.
Rights and receiving team
Specify source, licences, account ownership, documentation and a practical takeover exercise.
Milestone terms
Use the actual agreement for acceptance and billing. A service page cannot establish no-fee, fixed-price or pay-after-delivery terms.
Enterprise or continuing scope
Client/market matrix
Quote multiple deployments, shared tenancy, markets, currencies and operational support only where explicitly required.
Provider and data complexity
Separate multi-provider routing, issuer/bank partners, external reporting, data migration and retention obligations.
Service levels
Agree hours, severity, availability definition, response/repair targets, exclusions and remedies in a signed service agreement.
Named operation
Assign monitoring, incident, security-update, backup and recovery responsibilities; tools alone do not provide managed uptime.
Planning and change control
Keep current scope, budgets, review cadence, release evidence and dependencies visible without assuming unlimited capacity.
Exit and access
Maintain export/recovery and rights; transfer accounts through supported roles and revoke temporary supplier access safely.
Build scope
Count the user roles, permissions, workflows, client surfaces and admin operations. Identify where an inspected existing component actually fits and which gaps need new work. Price the agreed outputs rather than a catalogue label.
Integrations and data
Itemize provider onboarding, external-system contracts, legacy migration, data quality, reconciliation, media, messages and real-time work. Include test environments and provider restrictions, not only a connection button.
Non-functional requirements
Document accessibility, device/browser coverage, traffic and latency targets, resilience, retention and data location. Regulatory and security obligations need defined controls and review; they are not automatic properties of a framework.
Operation and ongoing costs
List hosting, database, storage, bandwidth, payment fees, maps, email/SMS, monitoring and any AI or video usage separately from engineering. Include maintenance, backups and support, plus who owns and pays each account.
Commercial terms
Request a current itemized written quote, acceptance-linked milestones and a change process. Confirm taxes, recurring charges, cancellation and rights. No price, duration, included support window or service level is established by this page.
An illustrative brief, not a claimed customer result.
Challenge to define
A proposed centralized spot venue needs explicit asset/pair rules, balances and reservations, customer and admin roles, custody and liquidity counterparties. This is an example brief, not evidence of a named customer or existing production base.
Proposed implementation to inspect
Evaluate reuse only after an authorized inspection. Walk an order from deposit credit and reservation through fill, fees, cancellation and withdrawal. Include ledger exports, chain scans, signing approvals and client status handling in the delivery inventory.
Acceptance and evidence still required
Accept only with replay/restart, rounding, negative-balance prevention, withdrawal and reconciliation evidence, plus agreed independent review and operator/legal readiness. No customer outcome, app count, delivered timeline or transferred rights is asserted.
Evaluate permissioned references and their limits.
No inherited testimonial, customer name, award, rating, project count, adoption, revenue or secured-value claim is asserted. A quote, case-study label or self-published facts ledger does not verify itself.
Relevant evidence
Ask for current, permissioned code/build/review and operating evidence tied to the proposed version. Establish what the supplier actually implemented and what was reused.
Respect boundaries
A reference or demonstration does not authorize customer-data disclosure or redistribution. A screenshot or code sample does not prove a complete working backend, legal rights, security or an operating result.
Diligence before a commitment.
Legal identity and contract
Verify the contracting entity and authorized signatory against current official records. Match the entity on the scope, invoice and rights agreement. Do not infer registration, history or financial standing from a website badge.
Evidence behind claims
Ask for dated, permissioned evidence behind project counts, app launches, outcome figures and technical claims. Check what was actually delivered, what belonged to an existing component and what remains a prototype or proposed scope.
Independent reviews
Open current review records and inspect author, project scope, date and platform verification. Treat ratings as context rather than a substitute for source, acceptance and receiving-team checks.
Relevant product inspection
Request access to the actual version proposed for the project, with safe test data and agreed permissions. Walk through the required role paths and failure states. A screenshot, catalogue name or attractive landing page does not establish a working backend.
Permissioned references
Where a past project matters, ask for a reference and permission to discuss it. Establish the supplier's role, delivery boundaries and current operator without republishing private customer information.
Named responsibilities
Ask who owns engineering decisions, QA, release approval and support. Record backups for unavailable contacts and how changes and unresolved risks will be reported. Do not substitute stock biographies or unverifiable team claims.
Accountable contracting party
Verify the actual authorized contracting identity and signatory. Unsupported incorporation, registration, staffing, history and guaranteed-outcome assertions have not been carried into this description.
Unresolved commercial contradictions
The inherited pages mix instant/source-at-start ownership language with later handover or final-payment language, and inconsistent delivery/support assertions. None is made authoritative here. Agree rights timing, milestones, support coverage and remedies in the signed scope.
Industry context changes acceptance.
Healthcare & Life Sciences
Keep patient records private and define actual consent/access, payment and retention duties with qualified advisers. A ledger or wallet does not supply clinical authorization.
Telemedicine
Verify clinical credentials, operating markets and provider/payment permissions separately, with private patient workflows and safe failure paths.
Fintech
Define actual custody, payment, exchange and reporting roles, legal authorization and reconciliation rather than rely on financial-product labels.
Retail & E-commerce
Include stock/availability, checkout, refunds, disputes, seller/customer rights, tax and financial reconciliation.
Media & Entertainment
Verify content rights, distribution, subscription/entitlement, store billing and moderation obligations; software does not supply a licensed library.
Creator Economy
Define creator identity, permitted content, subscriptions, sponsorship, moderation and payout eligibility with clear fees and privacy.
Transportation & Mobility
Test dispatch, location uncertainty, proof, cancellation, safety and permit/insurance requirements with actual operator responsibilities.
Food & Beverage
Define menus/stock, merchant/courier roles, order timing, food-safety responsibilities, refunds and payouts without claiming software establishes physical safety.
Rights, support and receiving-team handover.
Written scope
Describe included workflows, roles, interfaces, integrations, data and acceptance evidence. Record exclusions and assumptions so a feature name cannot stand in for an implementation contract.
Source, licences and accounts
Put the custom-code assignment, reusable-component licence and third-party restrictions in the contract. Identify every app, API, admin console, migration, infrastructure script and design asset being delivered. Keep cloud, domain, billing and developer-account ownership explicit. A source archive alone does not establish unrestricted rights or an independent release path.
Dependencies and changes
List customer inputs, provider approvals and third-party limits. Track changes with their scope, cost and milestone impact before proceeding. Separate engineering completion from app review, payment eligibility and the decision to open to customers.
Support and ongoing work
Agree the support start event, duration, working hours, contact route, severity definitions and response versus repair commitments in writing. Separate defects against accepted scope from new features, provider changes, security maintenance and operating work. Monitoring needs a named responder and an escalation route; a dashboard alone is not support.
Receiving-team handover
Require repository history, a dependency and licence inventory, setup instructions, API contracts, database migrations, environment-variable names, deployment and rollback steps, and an operating runbook. Transfer secrets through a secure channel rather than source control or a document. Have the receiving team build, restore and release with its own authorized access.
Use supported authorized account roles and secure credential transfer/rotation. Keep production keys, seed phrases, signing shares and API secrets out of ordinary briefs and handover documents. This website scope does not authorize spending, money movement or external account creation.
Questions about Crypto Exchange Development.
Can Omnistu build a crypto exchange from scratch?
An exchange scope can include matching, ledger, custody, identity, liquidity and trading/admin clients. Inspect any proposed base and define missing products and operating controls; this page does not establish available production inventory.
How much does crypto exchange development cost at Omnistu?
Use an itemized written quote for trading products, chains, custody, interfaces, integrations, review and operation. External assessment, provider charges and liquidity are separate decisions; inherited catalogue prices are not an available offer.
Does Omnistu deliver the full exchange source code?
Write the complete source and handover inventory into the agreement: engine, wallet/scanner services, web/mobile/admin clients, schema/migrations, history, tests and release/runbooks. Agree reusable and third-party licences as well as custom-work assignment; source delivery alone does not prove unrestricted IP.
How long does a crypto exchange take to deploy?
Set milestones from inspected code and requirements. Separate engineering acceptance from liquidity, banking, compliance, independent assessment and distribution approvals. No inherited ready-made or custom-build interval is promised.
How does Omnistu secure custody and withdrawals?
Define hot/cold policy, signer and backup control, approval thresholds, address/velocity limits and recovery. Verify the implementation and all policy-change paths. HSMs, multisig or a support label do not guarantee safe custody.
Which coins and chains can the exchange support?
Select assets and networks individually. Bitcoin, Ethereum and other EVM networks need tested node/scanner, address, fee, confirmation and reorganization behavior; token listing requires contract and asset-risk review, not merely an admin switch.
Do you include the trading interface and mobile apps?
List web, mobile and admin clients and their exact order, chart, account and risk functions in scope. Check real-time state, reconnects, stale prices, denied actions and device accessibility. Do not assume every client is bundled.
What happens if a bug is found after launch?
Agree defect coverage, severity, response hours, incident ownership, repair commitments and charges in signed terms. Keep security maintenance, provider changes, new assets and continuing custody operations distinct.
How does Omnistu handle NDA and IP for exchange projects?
Agree confidentiality before exchanging restricted details, and put rights, reusable-component restrictions, access and transfer timing in the contract. The inherited day-one versus final-payment ownership language is not resolved by a website promise.
Can Omnistu add P2P or OTC trading to an existing exchange?
P2P and OTC need their own escrow/quote, counterparty, dispute, credit and settlement rules. A shared ledger may support them if scoped, but migration requires verified balances, reconciliation and a rollback/cutover plan.
Does Omnistu provide the exchange licence or the liquidity?
Software does not supply legal permission, a banking relationship or funded liquidity. The operator must establish the actual authorization and counterparties. Integrations must match those approved roles and the relevant market restrictions.
How do you prove the exchange's balances are correct?
Test balanced postings, asset units, reservations, fees, duplicate/replay prevention and recovery, then reconcile assets, liabilities and pending external items per asset. A balanced ledger is not proof of reserves or solvency; a proof-of-reserves proposal needs its own complete liability and control assessment.
Implementation and platform references.
Use documentation for the selected versions, devices, configuration and operating region. Project acceptance depends on the implementation, not a tool label.
- Stripe: webhook delivery, verification and duplicate handling
- Stripe: idempotent request semantics
- PCI SSC: SAQ A eligibility and script protections
- Apple: App Review Guidelines
- Google Play: cryptocurrency exchanges and software wallets
- Apple: Secure Enclave key restrictions
- Android: Keystore security and hardware capabilities
- Ethereum: account abstraction routes
- Ethereum: proof-of-stake attacks and reorganizations
Bring your workflows and operating requirements.
Share the users, business rules, current code and data, integrations, device/browser targets and receiving team. Agree the build boundaries, rights, acceptance evidence and operating responsibilities before implementation.
Discuss your project โ