Documentation Index
Fetch the complete documentation index at: https://uncoded.ch/docs/llms.txt
Use this file to discover all available pages before exploring further.
This page is the conceptual mental model. Once you have it, the rest of the documentation maps cleanly. Read this before you read any module deep-dive — they will all reference these roles and flows.
The six modules and their roles
unCoded is built around the principle of separation of concerns: each module owns one well-defined job, communicates with the others through clean contracts, and can be developed, restarted, or replaced independently. This is what makes the system robust, observable, and operationally simple.TradingBot
The execution engine. The only component with authority to send a real order to your exchange. Reads your active configuration and turns intent into actual buys and sells, monitors fills, manages positions through to closure.
SignalEditor
The strategy authoring environment AND live evaluation engine. Where you compose strategies visually, preview them on history, and — once started — where they actually run live, evaluating market data on a schedule and emitting signals when triggers fire.
SignalsBot
The integration layer for incoming signals. Receives webhook signals from the SignalEditor’s running strategies AND from external sources (TradingView, custom scripts), validates them against your shared secret, and translates them into configuration updates the TradingBot reads.
Backtester
The historical simulation lab. Replays past market data through your strategy with a conservative fill model, producing reports with profit/loss, drawdown, win rate, and a per-trade ledger. Deliberately separate from the live runtime so you can simulate without affecting trading.
TelegramBot
The notification channel. Posts trade-close notifications, system alerts, and daily summaries to your Telegram chat. Notification-only by design — there are no chat commands. All operator control happens in the Dashboard.
Dashboard
Your authenticated control surface. A web cockpit that shows live positions, performance, system health, and lets you flip the kill switch, switch modes, allocate capital, or close positions manually.
A typical day, end to end
- You author a strategy in the SignalEditor.
- Once you click Start, the SignalEditor’s scheduler evaluates your strategy on your chosen timeframe (e.g., every
15mbar close). - When your trigger fires, the SignalEditor emits a webhook signal to the SignalsBot.
- The SignalsBot validates the signal (shared secret) and writes a configuration update.
- The TradingBot reads the updated configuration and places real orders on your exchange.
- As trades close, the result is written back to the configuration and visible to:
- The Dashboard (you check via browser)
- The TelegramBot (which pings you)
- You stay in the loop. The bot does the work.
What runs where
On your VPS (your responsibility)
On your VPS (your responsibility)
The four core services that your CapRover-style deploy brings up:
- TradingBot — the execution engine talking to your exchange.
- TelegramBot — the notification channel.
- Dashboard — the operator’s web cockpit.
- PostgreSQL — the local data store.
Optional add-ons (you start them when you need them)
Optional add-ons (you start them when you need them)
- SignalEditor — runs alongside the core stack when you want to author strategies visually. Once your strategy is saved and configured via the dashboard, the SignalEditor doesn’t need to run continuously.
- SignalsBot — runs when you want to receive webhook signals (from the SignalEditor’s scheduler or from external producers like TradingView). If you only use the bot’s pre-built modes, you may not need it.
- Backtester — runs on demand when you want to simulate a strategy. Most operators use a hosted Backtester (we run one for you) rather than self-hosting it, since backtests are heavy compute.
Vendor-operated services (we run these)
Vendor-operated services (we run these)
- License verification — a small centralized service that validates your unCoded license. It does not see your trading data.
- Hosted Backtester (optional) — for operators who don’t want to self-host the simulation engine. Runs as a paid feature for license holders.
The contracts between modules
Each module talks to its neighbors through clean, stable contracts. You don’t need to know the implementation details, but you should know the contracts because they define what’s possible and what’s safe.| Contract | What flows | Used by |
|---|---|---|
| Strategy definition | Your visually-authored strategies (indicators + conditions + triggers + risk rules) saved as files | SignalEditor publishes; SignalsBot/TradingBot/Backtester consume |
| Signal payload | A single trade signal: exchange, symbol, side, intent, confidence, timestamp | SignalEditor’s scheduler emits; SignalsBot receives; TradingBot acts |
| Configuration state | Your active mode, capital allocation, kill switch, per-pair settings | Dashboard writes; TradingBot polls; TelegramBot reads |
| Trade record | Every closed round-trip with realized P&L, fees, slippage | TradingBot writes; Dashboard displays; TelegramBot notifies |
- Replace any module with a different implementation that respects the contract.
- Add new sources (e.g., your own Python signal generator) without touching the core engine.
- Audit any trade back to the signal that produced it, and any signal back to the bar conditions that fired it.
Why this design matters for you
Robustness — partial failures don't cascade
Robustness — partial failures don't cascade
If one module crashes, the others keep working. If your TelegramBot loses connectivity, your trades continue executing — you just don’t get pings. If your Dashboard is down, the TradingBot keeps trading — you just can’t see the panels until it’s back. This is the operational benefit of separation of concerns.
Observability — every action is recorded
Observability — every action is recorded
Every signal, every trade, every operator action is logged. You can answer questions like “why did the bot trade XYZ at 14:32 on Monday?” by reading the trade record, then the signal record that caused it, then the bar values that fired the signal. No magic, no hidden state.
Upgrades — you replace modules independently
Upgrades — you replace modules independently
When unCoded ships an update, you upgrade one module at a time. The others continue running. There is no “forced full-stack redeploy” — you choose what to upgrade, when.
Scaling — you add what you need
Scaling — you add what you need
Want a second exchange? Run a second TradingBot container with a different
EXCHANGE_ID. Want multiple strategies isolated? Use sub-accounts. Want a more powerful Backtester? Move it to a beefier host. Each module scales independently because each owns one job.What this means in practice
What’s next
Architecture
A more visual look at how the modules deploy on your VPS and how data flows through the stack.
Glossary
Every term we use in this documentation, defined in plain language.
Module deep-dives
Detailed pages on each of the 6 modules.
Quickstart
The fastest path from this conceptual model to running trades.