Weple

When the rules are set but your hands cannot keep up

Algorithmic Trading Development

We turn the trading rules you already use into code, and build the environment that lets you run them over past data

What we build is software that follows your rules. Not returns.

Price, Pricing

You have the rules and you are still running them by hand

Even with the rules settled, running them by hand ties you to market hours, misses the moment a condition is met, and produces a different call each time at the same juncture. Wiring code straight into a live account is no better: when a run goes badly you cannot tell whether the rule was wrong or the code was. Turning the rules into code and being able to check that the code follows them are one job, not two.

What we do

  • Rules become conditions

    Entry, exit, stop loss, sizing, and re entry limits move from sentences into expressions the code can evaluate. Anything still ambiguous gets narrowed by questions until it can be written down.

  • An environment that runs over past data

    The same code can be run over historical periods. We write down what was assumed for fees, slippage, and fills, because a result with no stated assumptions cannot be read.

  • Broker and exchange connections

    Orders, fills, and balance queries go through the real API, with credentials kept outside the code. Coverage and terms differ by venue, so we confirm yours before connecting.

  • Paper trading first

    The same code runs in a paper environment before it touches a live account. Whether orders actually follow the rules is better observed before money is involved.

  • Stops where it has to stop

    We put the behaviour in code for a dropped connection, a rejected order, the same order about to be sent twice, and a daily loss limit being reached.

  • A record of what was ordered and why

    Every order is logged with the signal that triggered it, the time, and how it filled. When you revise a rule later, this log is what you read.

What gets handed over

The strategy rules written out in plain sentences, the periods and assumptions used for testing, how to read the logs, and how to start and stop the system. Interpreting performance and making investment decisions sit outside this document.

How it runs

  1. Write the rules down

    Send the rules you use now in plain writing. A spreadsheet or a memo as it stands is fine.

  2. Conditions and scope

    We turn them into a form the code can evaluate, and agree on how far to build and how long it takes.

  3. Build and verification

    The strategy code, the environment that runs it over past data, and the connections get built together.

  4. Paper run and handover

    After a paper run, you get the repository, the way to run it, and the documentation.

This fits

  • Someone with rules written in a spreadsheet or a memo, still executed by hand
  • Someone who wants to run the rules they use over past periods and see what comes out
  • A team that opened the broker API docs and stopped at authentication and order placement

Frequently asked

Will it make money?
We make no promise about performance. What we build is software that follows the rules you set and an environment that lets you check those rules against past data. Whether the strategy works, and every investment decision and its outcome, stay with you.
Will you design the strategy too?
The strategy is yours. Our part is putting it into code and making it checkable. It is fine if the rules only exist as sentences for now. We narrow them with questions until they are conditions the code can evaluate.
Is this investment advice or managed trading?
No. We only build software. We do not recommend instruments or timing, and we do not operate accounts on your behalf. The account and the credentials stay with you.
Which markets can you connect to?
Any market whose broker or exchange exposes an order API. Coverage and the terms around automated orders differ by venue, so tell us which one you use and we will confirm what is possible first.
Who owns the source code?
You do. The repository, the way to run it, and the documentation are handed over so another developer can pick it up.
Do you operate it afterwards?
This service ends at handover. If it turns out to need continuous attention, we carry on under the maintenance service.

Write the rules down and send them

Send the trading rules you use now in plain writing, and we will start by confirming whether they can be expressed as code.

See all services