Traadence's crypto backtesting tool is a research platform for active digital-asset traders who want to test their own rules without turning a historical chart into a sales pitch. It runs strategies on virtual money, applies trading costs before reporting performance, supports forward-testing through virtual wallets, and separates AI assistance from execution. The central design goal is simple: show whether a result survives realistic fees, slippage, and different market windows instead of rewarding one unusually favorable period.
A backtest is useful only when its assumptions are visible enough to challenge.
Why realistic execution assumptions matter
Historical results can look materially better when fills are assumed at ideal prices. TradingView's strategy documentation explicitly models commission and slippage because trading costs change simulated outcomes, while Backtrader's slippage model shows how market, limit, stop, and stop-limit orders require different fill assumptions. For crypto specifically, Kaiko's slippage benchmark demonstrates that slippage varies by venue, pair, time, and trade size. The engine therefore treats cost assumptions as inputs to the test, not footnotes added after the equity curve is drawn.
The report layer also looks for concentration risk in the sample. A strategy that depends on one short window, a handful of trades, or unusually favorable liquidity is flagged for review rather than promoted as a durable edge. The system combines closed-trade count, window consistency, drawdown behavior, fee drag, slippage sensitivity, and forward-test drift so the warning explains why a result looks fragile.
Core Features
| Feature | Description |
|---|---|
| Fee-aware backtest engine | Idealized results hide execution drag. The engine deducts configurable trading fees on simulated entries and exits so reported metrics reflect the chosen market assumptions. |
| Configurable slippage model | Perfect fills can create a false edge. Slippage is applied by order direction and test configuration, with assumptions shown beside results so the user can rerun harsher scenarios. |
| Honesty Report | A single lucky period can dominate a headline result. The report checks window dependence, trade-count adequacy, drawdown concentration, fee drag, slippage sensitivity, and divergence from forward-testing before assigning plain-language warnings. |
| 40+ indicator research layer | Manually wiring common indicators slows iteration and introduces inconsistent formulas. The charting workspace exposes more than 40 indicators that can be combined with declarative entry and exit conditions. |
| Declarative strategy editor | Copy-pasted strategy code makes comparison hard. Rules, parameters, timeframes, fees, slippage, and position settings are stored as structured configuration so runs can be reproduced and compared. |
| Virtual wallets and forward-testing | Historical fit does not show how rules behave as new data arrives. Virtual wallets replay strategy decisions on fresh market updates without sending live orders or touching real funds. |
| AI research assistant | Free-form AI output can blur the boundary between explanation and execution. The assistant helps explain reports, translate plain-language ideas into editable rules, and surface configuration conflicts; it does not issue trade signals or place orders. |
A research stack built for repeatable tests
| Layer | Implementation choice | Why it is used |
|---|---|---|
| Simulation engine | Python event-driven calculations | A deterministic numerical layer makes indicator calculations, fills, fees, and portfolio state inspectable and testable rather than hiding them behind model output. |
| Research store | PostgreSQL | Versioned strategy definitions, run parameters, trade ledgers, report metrics, and virtual-wallet snapshots stay queryable for run-to-run comparison. |
| Job execution | Isolated asynchronous workers | Longer historical runs execute outside the web request path, with job IDs, cancellation, retry controls, and immutable input snapshots for reproducibility. |
| Browser workspace | Interactive chart, strategy editor, run history, and report viewer | The user can move from visual inspection to configuration to result comparison without editing source code for every experiment. |
| AI boundary | Constrained model gateway over stored run data | AI receives test artifacts and strategy configuration for explanation or rule drafting, while the deterministic simulator remains the authority for fills and metrics. |
| Deployment package | Versioned service configuration and environment templates | The downloadable build keeps simulator, database, worker, and web-service settings reproducible across local, staging, and hosted environments without changing strategy logic. |
How the Honesty Report challenges a result
- Reprice the test. Recalculate the strategy after fees and slippage, then show gross-to-net cost drag instead of burying it in a settings panel.
- Check dependence on the selected window. Compare behavior across subperiods so one strong market regime cannot silently carry the full result.
- Inspect loss concentration. Surface max drawdown, clustered losing trades, and periods where the strategy stops behaving like its earlier sample.
- Compare with fresh data. Contrast historical behavior with the virtual-wallet forward test and flag material drift for manual review.
This is a diagnostic, not a certification. Market microstructure changes, and simulated slippage cannot perfectly reproduce future fills. Coinbase Institutional's market-impact research shows how execution cost changes with liquidity and order size. The product keeps those assumptions visible so a trader can challenge them instead of treating one backtest as a forecast.
Use Cases
- Reject a fee-sensitive strategy before forward-testing. A daily trader reruns the same rules with realistic cost assumptions and sees whether the result disappears after execution drag.
- Compare parameter changes without losing provenance. A systematic trader edits indicator thresholds or timeframes, then compares runs with the exact configuration and trade ledger preserved.
- Test a rule set on fresh data without live capital. Virtual wallets continue the strategy forward so the trader can compare out-of-sample behavior with the historical report.
- Review an AI-generated rule safely. The assistant converts an idea into editable declarative conditions, but the user verifies every parameter and the deterministic engine produces the actual test.
Performance and validation targets
| Check | Target or method |
|---|---|
| Run reproducibility | The same market data snapshot, strategy version, fee model, and slippage inputs must produce the same trade ledger and report hash. |
| Interactive feedback | Cached chart and prior-run views target sub-second retrieval; longer simulations remain asynchronous so the interface does not block on compute. |
| Sample warning | The report surfaces closed-trade count, tested window coverage, and concentration warnings; no universal sample threshold is presented as proof that an edge is durable. |
| Cost sensitivity | At least three cost scenarios can be compared from one saved strategy configuration: baseline, higher-fee, and higher-slippage assumptions. |
| Forward-test auditability | Every virtual fill stores timestamp, assumed fill price, fee, wallet balance, strategy version, and triggering rule for later review. |
Declarative strategy example
A saved strategy is represented as data rather than executable user code. That keeps the research artifact portable, reviewable, and easy to diff across experiments.
strategy: ema_rsi_pullback market: BTC-USD timeframe: 15m entry: all: - ema_fast > ema_slow - rsi < 45 exit: any: - rsi > 65 - stop_loss_pct: 1.2 costs: fee_bps: 10 slippage_bps: 5 wallet: mode: virtual
Project Directory
traadence-backtester/
├── apps/
│ ├── web/
│ │ └── src/
│ │ ├── charts/
│ │ │ └── BacktestChart.tsx
│ │ ├── reports/
│ │ │ └── HonestyReport.tsx
│ │ ├── strategies/
│ │ │ └── StrategyEditor.tsx
│ │ └── wallets/
│ │ └── ForwardWallet.tsx
│ └── api/
│ └── routes/
│ ├── backtests.py
│ ├── strategies.py
│ ├── wallets.py
│ └── reports.py
├── engine/
│ ├── simulation/
│ │ ├── event_loop.py
│ │ ├── fills.py
│ │ └── portfolio.py
│ ├── costs/
│ │ ├── fees.py
│ │ └── slippage.py
│ ├── indicators/
│ │ ├── registry.py
│ │ ├── momentum.py
│ │ ├── trend.py
│ │ └── volatility.py
│ └── honesty/
│ ├── window_checks.py
│ ├── sample_checks.py
│ ├── cost_sensitivity.py
│ └── drift.py
├── forward_test/
│ ├── virtual_wallet.py
│ ├── market_replay.py
│ └── audit_log.py
├── ai/
│ ├── rule_drafter.py
│ ├── report_explainer.py
│ └── guardrails.py
├── models/
│ ├── strategy.py
│ ├── backtest.py
│ ├── trade.py
│ └── wallet.py
├── tests/
│ ├── test_fees.py
│ ├── test_slippage.py
│ ├── test_reproducibility.py
│ └── test_honesty_report.py
├── config/
│ ├── indicators.yml
│ └── risk_defaults.yml
├── docker-compose.yml
├── pyproject.toml
└── README.md
The downloadable project includes the simulator, web workspace, data models, tests, configuration, and deployment files shown above. Traadence can also handle project setup, exchange-data integration, monitoring hooks, feature extensions, and ongoing maintenance against the same versioned strategy and report contracts.
How to Backtest Strategies Using Traadence's crypto backtesting tool
Download & Set Up the Project
Download, set up, and install Traadence's crypto backtesting tool to get the project running. If you hit any difficulty, contact us here.
Open the Research Workspace
Launch the web app, choose a crypto market and timeframe, then open the chart, saved-strategy panel, or virtual-wallet view for the next test.
Configure the Test
Select indicators and declarative entry/exit rules, then set date range, virtual balance, fee basis points, slippage basis points, and forward-test mode.
Run and Review
Press Run Backtest; the workspace returns trades, equity and drawdown charts, cost breakdowns, the Honesty Report, and a saved run for comparison.
Comparable research workflows
Experienced traders can benchmark the workflow against 3Commas backtesting for bot-oriented historical tests, Backtrader for code-first simulation, and custom Python research setups for full control. The difference here is not a promise of better performance; it is the combination of declarative rules, visible execution assumptions, virtual forward-testing, and a report designed to challenge fragile results before a trader gives them more weight.
Questions
Does the backtester use real funds or place live orders?
No. Historical tests and forward-tests run on virtual balances, and the AI layer cannot route orders to an exchange. The system is a research environment for evaluating user-defined strategy logic, not a signal service or live execution bot.
How are fees and slippage applied to simulated trades?
Fees and slippage are explicit test inputs applied during simulated execution, not subtracted as an afterthought. Each run stores those assumptions with its results, so the same strategy can be rerun under different cost scenarios and compared consistently.
What does the Honesty Report check before I trust a result?
It checks whether the result is overly dependent on a narrow date window, a thin trade sample, concentrated drawdowns, or favorable cost assumptions, then compares historical behavior with available virtual forward-test data. The report is a diagnostic warning layer, not proof that a strategy will behave the same way in future markets.