# Trading Software and Trading Bots, Built to Your Strategy

> Custom trading software and trading bots, built to your own strategy for any market with an API. You own the code, and it is tested before it trades.

Page: https://synapsereality.io/services/build/algorithmic-trading/
Last changed: 2026-11-16

## Scope

### This covers

Trading bots and trading software built to a client's own strategy, for any market that takes orders through an API.

### This is not

Investment advice or managing money, which we do not offer, and software that does not trade, which is custom software development.

### Measured by

Live fills that match the tested assumptions, inside limits agreed before launch.

## Overview

A trading bot is a short program with expensive ways to fail. The strategy can be the
smallest part of the code. The rest decides what happens on a partial fill, a dropped
connection, a rejected order or a restart in the middle of an open position.

We build trading software and bots to your rules. You bring a strategy, or an idea you have written as rules
you want tested. We write the rules down, test them, build the bot and run it in stages before it
trades at full size. The code, the strategy and the data stay yours.

We build and run trading software of our own. The method on this page is the one we use.

## Any market with an API

The engineering changes with the venue more than with the strategy. Each one settles,
charges and fails in its own way, and the bot has to be built around that.

- **Prediction markets** (Polymarket, Kalshi and other event exchanges). A contract pays a fixed amount if an event happens, so a price reads as a probability. The contract names the source that settles it. The bot has to follow that rule, because the outcome can turn on its wording.
- **Crypto** (Exchange APIs, on-chain swaps, market making). Trading never closes, so the bot runs unattended through the night. On-chain, every swap pays a network fee and can fill worse than quoted. Each order carries a slippage limit for that reason.
- **Sports exchanges** (Betting exchanges with an API, such as Betfair). In-play markets suspend at a goal, and an in-play order is held for a few seconds before it reaches the market. The bot treats a suspension as a normal state. Commercial use of Betfair's API needs Betfair's approval, so we check that first.
- **Stocks, futures, options and forex** (Broker APIs, MetaTrader 5, NinjaTrader, TradingView alerts). Sessions open and close, futures expire and roll, and margin decides how much the account can hold. The bot follows the calendar and the margin as closely as the price.
- **Other markets** (Event contracts, commodities, smaller exchanges). If a venue takes orders from a program, through an API or a FIX connection, we can build for it. We read its rulebook and its API terms before we quote.

## From written rules to full size

Nothing trades at size until it has passed every gate below. You see each result and
approve each step. A bot that fails a gate goes back one step, with the reason written down.

1. **Rules on paper.** Every entry, exit, size and stop is written as a rule a programmer cannot read two ways. We sign an NDA before you share it. Passes when you sign the rules off.
2. **Data checked.** Prices, fills and fees for the test period. Gaps, bad prints and changes of contract are found and listed. Passes when the data report says what was fixed and what was dropped.
3. **Backtest with costs.** Fees, spread and slippage go in. Look-ahead comes out. Every variant tried is counted. Passes when the result holds after costs and after the number of tries is accounted for.
4. **Paper trading.** The bot runs on live prices with no money at risk, for a period you agree. Passes when its decisions match what the backtest says it would have done on those days.
5. **Small live.** Real orders at a size you choose, under hard limits on position and loss. Passes when real fills sit close to the fills the test assumed.
6. **Full size.** Size goes up in steps you approve, with the limits raised one step at a time. Passes when limits, alerts and reconciliation held through the small stage.

## What a backtest has to survive

A backtest is a claim about the past, and it can be wrong in ways that look like profit.
We check for four before anyone trusts the result:

- **Look-ahead.** The strategy used a number that did not exist yet at that moment, such as
  a closing price used before the close.
- **Missing losers.** The test universe only holds markets or assets that still exist today.
- **Free fills.** Orders filled at prices nobody was offering, or with no fees and no
  slippage.
- **Too many tries.** Hundreds of variants were tested and the best one was kept. Its result
  is then partly luck. The deflated Sharpe ratio corrects for the number of trials.

If you already have a backtest or a running bot, we can check it on its own. That is the
[backtest audit](https://synapsereality.io/services/build/algorithmic-trading/backtest-audit/).

## The parts that keep a bot alive

The EU sets a floor for investment firms that trade by algorithm. Its technical standard
[RTS 6](https://eur-lex.europa.eu/legal-content/EN/TXT/HTML/?uri=CELEX:32017R0589) requires a kill
function, pre-trade limits on price, size and message count, and testing apart from production.
We build all three into every bot, whether or not the rule binds you. The rest of the list
decides whether a bot survives its first bad day:

- **Order state on disk.** Every order is recorded before it is sent. A restart reads that
  record, so it never sends the same order twice.
- **Limits outside the strategy.** Position size, daily loss and order rate are capped by a
  layer the strategy code cannot change.
- **A kill switch you can press.** One command stops new orders. A second one closes the
  open positions, if you want that.
- **Reconciliation.** On a schedule, the bot's own record of fills and positions is checked
  against the venue's. A mismatch stops trading and sends an alert.
- **Keys with no withdrawal right.** The bot holds trade-only API keys where the venue offers
  them. It can place orders. It cannot move your money out.

## What we do not do

We don't give investment advice, and we don't manage money. If you start from an idea, we test the
rules you give us on data and report the statistics, including when they show nothing. Which
strategy to run, and with how much, is your decision.

We don't promise returns. A bot runs a strategy faithfully. It cannot turn a losing strategy
into a winning one, and a good build makes a weak strategy fail faster and cheaper.

## Who it is for

A trader, a fund or a company with a strategy that runs by hand or in a spreadsheet. They need it to run unattended, as tested, inside hard limits.

## What you get

- The strategy written as rules, entry, exit, size and stop, signed off by you before any code is written
- A backtest on checked data with fees, spread and slippage in, and a report of what could make it wrong
- The bot itself in your repository, with market data, entry and exit logic, orders, positions and profit and loss
- Limits the strategy cannot change, on position, daily loss and order rate, and a kill switch you can press
- Paper trading and a small live stage, each compared with what the backtest said would happen
- Reconciliation against the venue's own records, and alerts sent to a channel you read
- A runbook and a handover, or hosting and monitoring on a monthly retainer, in your accounts

## How it runs

1. Write the rules down. We sign an NDA, then turn your strategy into rules a programmer cannot read two ways. If you start from an idea, you set the rules and we write them down. What they say is your decision.
2. Test on data. We clean the data for the period, then run the backtest with costs in and every variant counted. You get the result and the list of what could still make it wrong.
3. Build the bot. Market data, entry and exit logic, orders and positions, with the limits and the kill switch in a layer of their own. Every order is recorded before it is sent.
4. Run it in stages. Paper trading first, then real orders at a size you choose. Each stage is compared with the backtest, and size goes up only when you approve the step.
5. Hand over or keep it running. Your team gets the code, the runbook and a session where they stop, restart and redeploy the bot themselves. Or we host and watch it for a monthly fee.

## Questions

### Do you give trading advice or manage money?

No. We are a software company and we hold no licence to advise or to manage money. We build software to rules you set, and we test those rules on data. What to trade, and with how much, is your decision.

### Who owns the code and the strategy?

You do, all of it. The code lives in your repository from the first commit, and the strategy and the data are yours. We sign an NDA before you share the strategy, and we do not reuse it.

### Which markets can you build for?

Any venue that takes orders from a program, through an API or a FIX connection. That covers prediction markets, crypto exchanges and on-chain swaps, betting exchanges, and brokers for stocks, futures, options and forex. We read the venue's rules and API terms before we quote.

### How much does a trading bot cost?

We quote each project after a call, because the range is wide. Four things move it most. How many venues, how fast the bot has to react, how much data needs cleaning, and whether we host it afterwards.

### Will the bot make money?

We cannot promise that, and nobody honest can. A bot runs a strategy as written. The backtest and the staged launch tell you, before full size, whether the strategy holds up once costs and real fills are counted.

### Can you host and monitor the bot for us?

Yes, on a monthly retainer. The bot runs on servers we manage, in accounts that stay yours, with keys that cannot withdraw where the venue offers them. Alerts reach you and us. When the bot trades, and when it stops, is your call.

### We already have a bot. Can you check it?

Yes. The backtest audit is a separate job with a fixed scope. We reproduce your result, look for look-ahead, missing data, free fills and overfitting, and read the order path of a live bot. You get a written report.

## Related services

- [Prediction Market Bot Development](https://synapsereality.io/services/build/algorithmic-trading/prediction-market-bots/)
- [Crypto Trading Bot Development](https://synapsereality.io/services/build/algorithmic-trading/crypto-trading-bots/)
- [Backtest Audit](https://synapsereality.io/services/build/algorithmic-trading/backtest-audit/)
- [Custom Software Development](https://synapsereality.io/services/build/software-development/)
