When I defined the stop-loss in my trading system as "one tick below the valley low," I ran into something I hadn't thought carefully about before: what exactly is one tick? The answer turned out to be more nuanced than expected, and getting it wrong in code produces orders that either get rejected outright or fill at unintended prices. This post covers what minimum price increments are, why they differ by price level, and why this matters more than it might seem when building a trading system.
What a Minimum Price Increment Actually Is
A minimum price increment — often called a tick size — is the smallest unit by which a stock's price can move. Not every price is valid. Stocks don't trade at arbitrary numbers like $47.237 or $103.914. They trade at prices that fall on a defined grid, and the spacing of that grid depends on where the price currently sits.
Most major exchanges, including those in Korea and many others globally, apply a tiered structure: the minimum increment is smaller for lower-priced stocks and larger for higher-priced ones. As a concrete example of how this tiering works in the Korean market: stocks priced below 2,000 KRW move in increments of 1 KRW; between 2,000 and 5,000 KRW, the increment is 5 KRW; between 5,000 and 20,000 KRW, it's 10 KRW; and so on, with increments growing to 500 or 1,000 KRW for stocks priced in the hundreds of thousands. The specific thresholds vary by exchange and can be updated by regulators, so always verify the current rules before building anything that depends on them.
Why the Tiers Are Designed This Way
The tiered structure exists to keep the increment proportionally meaningful at every price level. If every stock moved in 1 KRW increments regardless of price, a 500,000 KRW stock would have an order book with half a million distinct price levels between zero and its current price — an absurd and unmanageable amount of granularity. Conversely, if every stock moved in 1,000 KRW increments, a 1,500 KRW stock could only trade at 1,000 or 2,000 — a 67% gap between adjacent valid prices, which makes precise trading effectively impossible.
The tiered approach keeps any single tick roughly proportional as a percentage of the stock price across different price ranges. That proportionality is what makes the order book readable and the price discovery process functional.
Why This Matters When Writing Trading Code
In a live trading system, this becomes a precision requirement. Say the algorithm calculates a stop-loss at "1.0% below the recent high" and the recent high was 37,650 KRW. One percent below that is 37,273.5 KRW — a price that doesn't exist. Any order submitted at that price will either be rejected or rounded to the nearest valid increment by the brokerage system, landing at a price slightly different from what the algorithm intended.
At first glance, a rounding error of a few won seems trivial. But across hundreds of trades, or in situations where the stop-loss level is close to a support zone, even small discrepancies between the intended price and the actual submitted price can produce unexpected behavior. More practically, if the system is designed with specific risk thresholds in mind, having the actual filled price consistently drift from the calculated price undermines the reliability of those thresholds.
The fix is to build a tick-size lookup into the code: before submitting any order, first determine which price tier applies, retrieve the correct increment for that tier, and round the calculated price to the nearest valid multiple of that increment. This is a small function but a necessary one — without it, the system is submitting prices that may or may not be valid depending on where the current price happens to fall.
The Same Issue Appears on the Buy Side
Grid entry prices have the same problem. If the grid calculates a buy level as 3.7% below a reference high, the result is almost certainly not a valid price. Every grid level needs to go through the same rounding step before the price is usable in an actual order.
This is one of those details that doesn't appear in beginner tutorials on trading systems, because it's not conceptually interesting — it's just a necessary constraint of how markets work. But skipping it in implementation produces a system that runs cleanly in backtests on paper but generates invalid orders or unexpected fills when deployed live.
Today's Investing Insight — Bid-Ask Spread and Liquidity
The bid-ask spread — the gap between the highest price a buyer is willing to pay and the lowest price a seller is willing to accept — is closely related to tick size and liquidity. In actively traded large-cap stocks, the spread is usually just one tick wide, because there's always a counterparty ready to trade just one increment away. In thinly traded stocks, the spread can be many ticks wide, meaning the price you buy at and the price you could immediately sell at differ significantly. This gap represents an immediate, built-in cost every time you trade. Trading systems that work well in liquid markets can perform much worse in illiquid ones simply because the spread eats into every entry and exit. Filtering by minimum trading value — as this system does — is one way to systematically avoid the worst of this problem.
---
This post documents a personal journey of building an algorithmic trading system, combined with general explanations of market mechanics, and is not a recommendation of any specific stock or trading strategy. Market structure rules including tick sizes are subject to change by exchange regulations. All investment decisions and their outcomes are the sole responsibility of the investor.
Comments
Post a Comment