Algorithmic trading bot

What this actually solves

You already have a way of trading that you operate by hand, and you have run out of yourself. You cannot watch two exchanges at once, you cannot be awake for a market that never closes, and — the part people admit more quietly — your own execution changes depending on how the last few trades went. Fear makes you skip an entry that met every condition. Impatience makes you take one that did not. The rules were consistent; the human running them was not.

That is precisely what this work addresses, and understanding it correctly is what makes the project succeed. You are not buying profit. You are buying faithful execution of your own method, plus an honest measurement of what that method would actually have done after costs. We are explicit about this before starting, because the most damaging version of this project is one where both sides quietly expect the software to supply the edge. Writing the bot is the straightforward part. The strategy is the hard and valuable part, and it belongs to you.

How the build runs

1. The strategy written down until it is unambiguous. Entry conditions, exit conditions, position sizing, and the case people forget — when the bot should do nothing at all. Every rule has to be reducible to a computation on data the bot can actually see at that moment. This stage almost always changes the strategy, because describing a discretionary method precisely exposes the judgement calls hidden inside it. Four to seven days.
2. Data, and refusing to fake it. Historical candles pulled through ccxt and cached locally, with explicit checks that report missing candles and duplicate timestamps rather than silently forward-filling them. A backtest that quietly invents prices across an outage produces results that cannot happen. Three to six days.
3. A backtest engine built to be pessimistic. Two rules govern it. Signals computed on a candle can only be executed at the open of the next one, so the engine cannot accidentally trade on information that did not exist yet. And costs are modelled and configurable — taker fees on both sides, slippage on both sides, and funding applied to positions held across each funding period on perpetuals. Results are always printed with and without costs, side by side, because the difference between those two columns is the entire conversation. Two to four weeks.
4. Walk-forward testing and an honest report. Parameters optimised on one window and tested on the following unseen window, rolled forward across the full history, with each out-of-sample period reported separately. The report covers maximum drawdown, Sharpe and Sortino, win rate, average win against average loss, longest losing streak, trade count and total fees paid as a share of starting equity — because total return on its own tells you almost nothing about whether a person could have stayed in the seat. One to two weeks.
5. Paper trading on live data. The bot runs against the real market in real time and records what it would have done without placing a single order. This is a mandatory stage in every quote we write, minimum two to four weeks, because backtests run on tidy history while live markets deliver latency, partial fills, thin books and exchange maintenance. The gap between the two is the thing you need to see before money is involved. Two to four weeks.
6. Live execution at small size, with the limits wired in first. Risk controls go in before the first live order — per-trade stop, daily loss limit, maximum drawdown halt, position caps and a kill switch. Keys are created by you with withdrawal permission off and an IP allowlist on. Then deployment to a supervised server, structured logging, alerts, and a handover that states exactly what stops the bot and why. One to three weeks.

What moves the price

Whether the strategy arrives or has to be developed. Encoding a set of rules you already run is one job. Research — hypothesis generation, feature work and repeated testing — is a different and considerably larger one, and confusing the two is the main reason these projects get mispriced.

How many exchanges and instruments are involved. One market on one exchange is contained. Several venues means reconciling different fee schedules, symbol conventions, rate limits, minimum sizes and outage behaviour, and cross-venue logic multiplies the failure modes you have to handle.

How execution-sensitive the approach is. A strategy acting on hourly candles is forgiving. Anything where fill quality drives the result — tighter timeframes, market making, or orders large enough to move a thin book — needs order routing, partial-fill handling and latency work. The range is $2,000–$25,000 over 1–4 months, set mostly by those three factors.

What usually goes wrong

Fees and slippage are left out of the backtest. The resulting equity curve is beautiful, every single time, and it is the reason a strategy can look excellent on paper and lose money as soon as it trades. Costs apply on both sides of every trade, so an active strategy pays them constantly, and on perpetuals funding is charged again on anything held across a funding period. A method that is only marginally positive before costs does not survive them, and that arithmetic is the first thing our reports show.

Parameters are optimised on the same data used to test them. Try enough moving average lengths against a long enough history and something will look outstanding — including on data with no predictive content at all. It is fitting, not discovery, and it falls apart immediately in live trading. Walk-forward testing, where the parameters are chosen on one period and judged on the next unseen one, is the only thing that separates the two, and results are reported per out-of-sample window rather than as one flattering total.

The bot restarts and forgets it already has a position. The connection drops, the process is restarted, and the strategy re-evaluates from scratch with no memory of the open position it already holds — so it sends a second order and now carries double the intended size, outside every limit that was carefully configured. The fix is a rule applied on every single start-up: the bot reconciles its state from the exchange itself, reading actual open positions and live orders, and never trusts its own stored memory of what it thinks it did.