Algorithmic trading: the honest version, for people who are not quants

A pension fund needs to buy 40,000 index futures contracts. Sent as one order, the price runs away before the fill is done and the fund pays a fortune for its own impatience. So it doesn't. It hands the order to a program that slices it into small pieces and feeds them into the market over four hours, tracking the volume-weighted average price so the fills look like the day's average instead of like a whale arriving.

That is algorithmic trading. It is not trying to predict anything.

Meanwhile a person with a laptop in a spare bedroom has written a program that decides whether to buy one micro contract at 9:30 AM ET. That is also called algorithmic trading. The two activities share a name, a programming language, and almost nothing else.

What the term means, and where it came from

Algorithmic trading is the use of a computer program to make trading decisions, place orders, or both, according to rules defined in advance. The word covers everything from a three-line moving average crossover to a market-making engine handling millions of messages a second.

The term grew out of institutional practice. In the 1980s, US desks ran program trading: computer-assisted baskets of stocks traded against index futures for arbitrage. In the 2000s, banks built algo desks whose job was to break large client orders into pieces the market would not notice. Retail borrowed the vocabulary later, once electronic exchanges and platforms with scripting engines put the same basic capability on a desktop.

Which is why the word is now nearly useless on its own. Ask what the algorithm decides, and you learn more in one sentence than from any brochure.

It is also worth saying what the term does not imply. An algorithm is not artificial intelligence. Most production trading algorithms, institutional ones included, are explicit rules a person wrote down and can read back. It is not a forecasting engine, since the majority of algorithmic volume is execution work on decisions already made. And it is not a guarantee of sophistication: a bad idea expressed in C# is still a bad idea, now running faster and without hesitation.

Execution algorithms and signal algorithms are not the same thing

This is the distinction that makes everything else legible. An execution algorithm assumes the decision has already been made and worries about the fill. A signal algorithm makes the decision and mostly ignores the fill, because it is trading a size the market does not notice.

If you trade one to five micro contracts, execution algorithms are irrelevant to you. Your order is a rounding error in a market that trades hundreds of thousands of contracts a day; you get filled at the price on the screen, minus a tick of slippage now and then. Everything that matters for you sits in the last row of that table. Practical detail is in how a trading algorithm works.

High-frequency trading, and why you are not playing that game

High-frequency trading is a subset of algorithmic trading defined by one thing: speed as the source of the edge. HFT firms make money on very short-lived pricing discrepancies and on market making, holding positions for seconds or less and finishing most days close to flat.

The infrastructure is the business. Servers colocated in the exchange's own data center. Microwave and laser links between Chicago and New Jersey because fiber is too slow. Hardware that processes market data on the network card. Engineers whose salaries alone exceed most retail accounts. The competitive unit is the microsecond, and the barrier to entry is measured in millions of dollars a year.

You cannot win a race that is decided before your screen has finished drawing the candle.

The useful conclusion is not "give up." It is that speed cannot be your edge, so it must be something else: patience, a specific recurring situation, disciplined risk, and a willingness to sit out days when nothing lines up. A system that trades one window a day and holds a position for forty minutes is not competing with HFT in any meaningful sense. It is playing a different sport in the same stadium.

What a retail algorithmic trader actually uses

The real toolkit is smaller and duller than the word "quant" suggests.

Notice what is not on the list: a machine-learning cluster, alternative data, a co-location contract. Those belong to a different scale of operation. What the platform can and cannot do is covered in NinjaTrader 8 explained, and the honest state of machine learning in this field is in machine learning in trading.

From idea to live orders

The pipeline is the same whether one person or forty are working on it. Skipping a stage is how people lose money slowly and then quickly.

1. Specify. Write the rule in words a stranger could follow: entry condition, position size, stop, target, exit time, what to do on a gap. If it cannot be written unambiguously, it cannot be coded.
2. Test on history. Run it over years of data, with realistic commissions and slippage subtracted. A backtest that ignores costs is a marketing document.
3. Test out of sample. Hold back a period the rule was never tuned on, and check it there. This is the only stage that can catch curve fitting, and it is the stage most often skipped.
4. Forward test in simulation. Run it live on real-time data with no money at risk, to catch everything the historical test could not see: rejections, latency, session handling, your own nerves.
5. Deploy small, then monitor. Minimum size, full logging, and a written rule for when you would turn it off, decided before you need it.

The edge is small, and it is fragile

An edge is a positive expected value per trade. That is the whole concept, and it is smaller than people imagine. Take the published Algomyth backtest and do the arithmetic in the open: $77,809 gross across 914 trades, over 44 months on mid-size funded accounts.

$77,809 ÷ 914 is about $85 per trade gross. Take off the roughly 5% the report subtracts for commissions and slippage and expectancy lands near $81 per trade, which is where the ≈$73,900 net comes from. Those are simulated results over historical data, not a live account.

Eighty dollars a trade is the entire business. It is also why costs matter so much: at roughly $1 per micro contract, commissions and slippage take about 5% of the gross, and a couple of extra ticks per trade would take a great deal more. See slippage and commissions.

Fragility comes from the same place. An edge exists because some recurring behavior in the market has not been fully competed away. Behaviors change, participants change, and a rule tuned too tightly to one period stops working in the next. Nothing announces this. You find out from the distribution of your own results, slowly.

How you measure one, and how each number lies

Every metric in this field hides something. Reading them in pairs is the only defense.

For reference, the Algomyth backtest reports a profit factor of 1.54 and a maximum drawdown of $4,432 over 44 months on mid-size funded accounts. A profit factor near 1.5 is a normal, workable number for a real system. Anything advertised above 3 over a long period should make you ask what the test left out.

What it costs, retail versus institutional

The asymmetry is not where people expect. Retail pays more per contract and vastly less for everything else.

The last row is the one that changed retail algorithmic trading. A proprietary firm evaluation caps what you can lose on a single attempt at the fee, instead of at the size of your account. The trade-off is their rulebook and their profit split. The mechanics are on funded capital.

Two costs get left out of every budget. The first is data twice over: a historical set deep enough to test on, and a live feed to trade on, which are separate products even when one vendor sells both. The second is your own time. Specifying, coding and testing a strategy properly is weeks of evenings, and most of those weeks end with a result that says the idea does not work. That is the job functioning correctly, and it is the part nobody prices.

Where algorithms fail

• Curve fitting. Parameters tuned until the historical curve looks beautiful. The system then trades a pattern that existed only in that sample. The defense is out-of-sample data and few parameters. See overfitting and curve fitting.
• Look-ahead bias. The code uses information that was not available at the moment it claims to have acted: a closing price during the bar, a revised data series. It produces beautiful backtests and losing accounts.
• Costs left out. A strategy with a $60 edge per trade dies if the test forgot $30 of commissions and slippage.
• Regime change. The market that produced the edge is not the market you are trading now. Volatility shifts, participants leave, a behavior gets crowded out.
• Silent breakage. A platform update, an expired data subscription, a rejected order nobody read. The system is not losing; it simply is not running.
• Selection bias in your own research. Test two hundred variations and the best one will look excellent by chance alone. The winner of a large search is not evidence; it is the survivor of a lottery you ran yourself.
• The operator. Turning it off in a drawdown, doubling size after a good week, editing a parameter mid-quarter. Each one replaces a tested system with an untested one.

What one person with a laptop can and cannot do

Being honest about this is more useful than being encouraging about it.

Cannot: compete on latency, buy alternative data, employ researchers, run forty uncorrelated strategies to smooth the equity curve, or survive a bad year because another desk carried the firm. Cannot get institutional commissions. Cannot make a fragile edge robust by wanting it more.

Can: trade one deeply liquid market where fills are honest. Focus on a single recurring situation instead of covering everything. Sit out most of the session, which no institution mandated to be invested is allowed to do. Hold a rule unchanged for years, because nobody is asking for quarterly performance. Keep costs near zero apart from commissions. And use somebody else's capital through a funded account, which caps the downside at a fee.

That is a real list. It is not a small one. It is just not the list people are sold when the word "quant" appears in an advertisement. The wider comparison of what is actually being offered is in best trading systems and, for the AI end of the market, AI trading.

Where Algomyth sits in all this

Algomyth is a signal algorithm, not an execution algorithm. It is written in NinjaScript for NinjaTrader 8, trades US index futures on micro contracts, and answers exactly one question once a day: long, short, or flat.

• One window, at 9:30 AM ET, when the US cash market opens and the day's volume arrives. If the read is not clean, it does not trade that day.
• Stop and target placed in the market in the same instant as the entry, with the target at 3× the risk.
• No overnight positions, ever. The trade ends at the target, the stop, or the end of the window.

The published backtest covers 44 months day by day, from January 2023 to September 2026, on mid-size funded accounts: $77,809 gross, ≈$73,900 net after commissions, 914 trades, profit factor 1.54, maximum drawdown $4,432. With the target at three times the risk, break-even sits at a 25% win rate. The mechanism is on how it works, and the drawdown behavior on the risk page.

If you want to start from the mechanics rather than the theory, automated trading covers the whole operation end to end, futures trading bot covers this specific market, and get started is the install path.

Frequently asked questions

What is the difference between algorithmic trading and automated trading?

In practice the terms overlap, but the emphasis differs. Algorithmic trading describes rules expressed as an algorithm, including execution algorithms that never decide direction at all. Automated trading describes the orders being sent by a machine without a human clicking. A retail system that decides and executes on its own is accurately described by both words.

Do I need to know how to code to use algorithmic trading?

To build your own strategy, yes: realistically C# for NinjaScript, plus enough Python to explore data. To run one somebody else wrote, no. You install a compiled strategy, set its parameters and start it, which is closer to installing software than to programming. What you do need either way is the ability to read a performance report critically.

Can a retail trader beat hedge funds?

Not at their own game, and the question is the wrong one. A fund is judged on returns against a benchmark while managing billions, which forces it to stay invested and to trade sizes that move markets. You have no benchmark, no investors and no size problem, so you can wait for one specific situation and take nothing else. That is not beating them; it is playing where they cannot.

How much historical data do I need to test a strategy?

Enough to include more than one kind of market: trending, choppy, calm and violent. For a system taking roughly one trade a day, several years is the practical minimum, which is why the Algomyth report covers 44 months rather than a good quarter. Sample size matters as much as span. A few hundred trades is a weak experiment no matter how many years it spreads across.

Is algorithmic trading legal for individuals in the United States?

Yes. Running an algorithm in your own account is legal and ordinary, and programs already account for much of the volume on US futures exchanges. Registration with the CFTC and NFA applies to people managing other people's money or advising for compensation. Your results are still reportable to the IRS, and futures carry their own treatment under Section 1256.

Is machine learning better than a rule-based algorithm?

Not for most retail purposes. A model with thousands of parameters fitted to a few thousand trades is a curve-fitting machine with better marketing, and when it degrades nobody can say why. Rule-based systems have the opposite properties: fewer parameters, an explanation you can audit, and a failure you can diagnose. That transparency is worth more than a slightly better backtest.