Paper trading is the step between a backtest that looks good and money that can actually be lost. Almost everyone skips it, and the ones who skip it pay the market to find bugs that a simulation would have shown them for nothing.
This covers what it is genuinely for, the options available in India, how to build a simple simulator yourself, and the specific question nobody answers well: how do you know when you are done paper trading?
What paper trading catches that a backtest cannot
These are two different tests and people conflate them constantly.
A backtest answers one question: would these rules have made money in the past? It runs on clean historical data, at your own pace, with no network, no broker and no clock.
A paper trade answers a completely different one: does my system actually work? It runs on live data, in real time, against a real broker connection, with everything that involves.
Here is what only paper trading finds:
- The access token that expired overnight, so the bot starts and does nothing
- The order rejected for insufficient margin, which the backtest never had to think about
- The WebSocket that dropped at 11:40 and never reconnected
- Your loop taking longer than expected during a fast move, so signals arrive late
- The holiday your calendar logic did not know about
- Rules that turn out to contradict each other in a situation the historical data never produced
None of those are strategy problems. They are all engineering problems, and every one of them costs real money if discovered live.
The options in India, in order of effort
Broker paper-trading modes. Some Indian platforms offer a simulated mode or a virtual portfolio feature. Convenient, and the limitation is that you are testing their simulation rather than your own code path — which means the bugs above may not surface.
Platform simulators. Streak and TradingView both support forward-testing a strategy on live data without orders. Good for validating whether the logic holds up in current conditions. Same limitation: your production code is not what is running.
Your own simulator. The same program you will run live, connected to the same live data feed, with the order-placement function swapped for one that records the trade instead of sending it. This is the only version that tests what you will actually deploy, and it is far less work than it sounds.
If you are learning to code your own system, the third option is the one worth building. The first two are useful while you are still deciding whether an idea is worth coding at all.
Building the simulator: one switch
The whole trick is that your strategy should never call the broker directly. It calls a function, and that function decides whether to send an order or record one.
PAPER = True # ek line, live aur paper ke beech
class Broker:
def __init__(self, kite, paper=True):
self.kite = kite
self.paper = paper
self.fills = []
def buy(self, symbol, qty, price):
if self.paper:
self.fills.append({
'side': 'BUY', 'symbol': symbol, 'qty': qty,
'price': price, 'time': now_ist()
})
log.info('PAPER BUY %s %s @ %s', qty, symbol, price)
return 'PAPER-' + str(len(self.fills))
return self.kite.place_order(
variety=self.kite.VARIETY_REGULAR,
exchange='NSE', tradingsymbol=symbol,
transaction_type='BUY', quantity=qty,
product='MIS', order_type='MARKET')
Everything above that line — the data feed, the indicator calculation, the signal logic, the position tracking, the risk checks — is identical in both modes. That is the point. When you flip PAPER to False, the only code path that changes is the one that sends the order.
Make the simulation pessimistic, not optimistic
A paper trade that assumes you got filled at the price on screen is a lie you are telling yourself in slow motion. Three adjustments make it honest.
Fill at the wrong side of the spread. If you are buying, assume you paid the ask, not the last traded price. On liquid instruments the difference is small; on anything else it is most of your edge.
Subtract full costs on every simulated trade. Brokerage, STT, exchange charges, GST, stamp duty. Model them as a single pessimistic figure per side if computing each is tedious, but do not leave them out.
Add slippage deliberately. Assume the market moved against you between signal and fill, because in a fast market it did. A few basis points on liquid index instruments, more on anything thin.
SLIPPAGE = 0.0005 # 5 bps
COST = 0.0006 # brokerage + taxes, per side
def simulated_fill(side, quoted):
px = quoted * (1 + SLIPPAGE) if side == 'BUY' \
else quoted * (1 - SLIPPAGE)
return px * (1 + COST) if side == 'BUY' else px * (1 - COST)
If the strategy is still profitable under pessimistic assumptions, you have learned something. If it only works when you assume perfect fills, you have learned something more valuable.
What to record, and what to compare
The purpose of the exercise is comparison, so the log has to support it. For each simulated trade, record the timestamp, the signal that triggered it, the quoted price, the simulated fill, the quantity, and the reason for the exit.
Then, weekly, compare three things against your backtest over the same rules:
- Trade frequency. If the backtest produced eight trades a week and live conditions produce two, your signal is rarer than you thought or a filter is behaving differently on live data.
- Average win and average loss. These drifting apart from the backtest usually means costs or slippage were underestimated.
- The sequence of outcomes. Not just the total, but whether the losing runs look like the ones the backtest showed.
Divergence is not failure. It is the information you came for. The failure mode is running a paper trade for six weeks and never comparing it to anything.
How long, and how do you know you are done
The common answer is one month, and it is the wrong unit. What matters is trade count and condition variety, not calendar days.
Reasonable bars to clear before going live:
- At least thirty trades. Below that the results are noise wearing a suit.
- At least one expiry week if you touch derivatives, because the market behaves differently in it.
- At least one genuinely volatile day. A system that has only run through calm markets is untested where it matters.
- Zero unhandled errors in the last two weeks. Not fewer — zero. Every crash is a position that would have been left unmanaged.
- Live results within a defined distance of the backtest. Decide that distance in advance rather than after seeing the numbers.
A strategy that trades twice a week needs about four months to clear thirty trades. That is a real cost and it is still cheaper than the alternative.
Then go live small, which is a third stage
Paper trading ends and live trading does not begin at full size. There is a stage between them that people collapse into one.
Go live at the smallest quantity the instrument permits and keep it there until live fills match paper fills. This catches the last category of problem, the one no simulation can: what the market actually gives you when you are a participant rather than an observer. If your live fills are consistently worse than your simulated ones, your slippage assumption was too generous and every projection built on it was too.
Only when those two sets of numbers agree does position size start increasing, and by a rule decided in advance rather than by how the month felt.
All three stages need a broker account — the live data feed that makes paper trading meaningful comes from the same place the orders eventually will.
Paper trading needs a real data feed
The account supplies the ticks; whether orders are sent is your switch. Free to open
The virtual trading system, the pessimistic fill model and the comparison discipline above are all part of our Algorithmic Trading with Python course at Rs 24,900 — one payment, permanent access, free demo on WhatsApp first.
We sell no tips and no signal group, we manage nobody's money, and we promise no returns. Trading carries a real risk of loss.
Disclosure: the account-opening link on this page is under Atul Shrivastava's Zerodha Authorised Person registration (NSE AP Reg: AP2516003481; Zerodha Broking Ltd. SEBI Reg: INZ000031633) and earns a revenue share. TheFinBaba is not a SEBI-registered Investment Adviser — this content is educational, not investment advice.
Frequently Asked Questions
What is paper trading?
Running a strategy on live market data in real time without sending real orders. Unlike a backtest, which tests whether the rules would have worked historically, paper trading tests whether your actual system works - the connection, the tokens, the timing and the error handling.
Is paper trading available in India?
Yes, in three forms: simulated modes on some broker platforms, forward-testing on tools like Streak and TradingView, and your own simulator built by swapping the order-placement function in your code. The third is the only one that tests the code you will actually deploy.
How long should I paper trade before going live?
Judge by trade count, not calendar days. At least thirty trades, at least one expiry week if you trade derivatives, at least one volatile day, and two full weeks with zero unhandled errors.
Why do my paper results look better than my live results?
Almost always fills. A simulation that assumes you got the price on screen ignores the spread and slippage. Model buys at the ask, sells at the bid, subtract full costs, and add a deliberate slippage assumption.
Can I paper trade without any coding?
Yes. Streak and TradingView both let you forward-test a strategy on live data without placing orders. What that will not test is your own code path, so it validates the idea rather than the implementation.
Does paper trading need real money in the account?
No capital is at risk, but you do need a broker account for the live data feed, and an API subscription if your simulator connects programmatically. The orders are what you withhold, not the connection.
Related Reading
- Backtesting a trading strategy in Python
- How to start algo trading in India - the full sequence
- Live tick data with the Kite Connect WebSocket
- Risk management in trading
- Choosing a broker for algo trading in India
- Algorithmic Trading with Python - full syllabus
Disclaimer: TheFinBaba provides educational content only - this is not investment advice. Trading involves risk of loss.
