Start Algo Trading with ₹1 Lakh Capital Using a High Probability Options Strategy

Tradehull_Imran · June 18, 2026, 9:40am

If we want to start algo trading with a relatively small capital base like ₹1 lakh, we need a setup that does two things well. First, it must fit comfortably within the capital limit. Second, it should offer a strong probability of profit so that we are not depending on a few lucky trades.

One practical way to do that is with DOS, or Directional Option Selling . This is a structured options strategy built around market direction, delta based strike selection, and strict risk management. When used properly, it can be traded with less than ₹1 lakh margin and can be designed around a probability of profit above 80%.

What is Directional Option Selling?

DOS stands for Directional Option Selling . The idea is simple.
We first identify the market direction.
Then we sell an out of the money option in that direction bias.
We hedge it by buying a farther out option.
We manage the trade with predefined profit booking and stop loss rules.

This is not a random option selling approach. It is rule based. That makes it suitable not only for manual execution, but also for algo trading and automation later.

Step 1: Find the Direction of the Market

Since this is a directional strategy, the first job is to decide whether the setup is bullish or bearish.

A simple way to do this is by using Supertrend with settings 10 and 3 . For intraday trading, the setup uses a 5 minute timeframe .

If Supertrend is green , we treat the market as bullish.
If Supertrend is red , we treat the market as bearish.

This directional filter decides whether we work with puts or calls.

How the directional logic works

Bullish setup: sell a put and buy a lower strike put as hedge.
Bearish setup: sell a call and buy a higher strike call as hedge.

So if the market is bearish, we operate on the call side. If the market is bullish, we operate on the put side.

Step 2: Select Strikes Using Delta

The real edge in this setup comes from delta based strike selection .

Instead of choosing strikes by guesswork or by fixed point distance, we choose them based on option delta.

Strike selection rules

Sell the option with delta near 0.20
Buy the hedge option with delta near 0.10

That means:

In a bearish trade , we sell the call with delta close to 0.20 and buy the call with delta close to 0.10.
In a bullish trade , we sell the put with delta close to 0.20 and buy the put with delta close to 0.10.

This creates a hedged short option structure with a defined risk profile.

Example of the Setup

Suppose the market direction is bearish based on Supertrend. In that case:

We go to the option chain.
We locate the call option with delta closest to 0.20 .
That becomes the short call strike .
Then we locate the call option with delta closest to 0.10 .
That becomes the hedge call strike .

In the example discussed, the short strike was around 23350 and the hedge strike was around 23750 . The exact strikes will always depend on the option chain at that moment, which is why delta based selection is more robust than choosing arbitrary levels.

Can This Be Traded with ₹1 Lakh?

Yes, that is one of the main reasons this setup is useful for beginners exploring algorithmic trading with small capital.

In the example, the margin requirement was about ₹63,000 . That is comfortably below ₹1 lakh and still leaves extra capital in the account.

That leftover margin matters. We do not want to use the full account balance on one structure. Keeping buffer capital gives the trade room to function and avoids pressure from tight margin utilization.

Why this capital structure works

Margin stays below ₹1 lakh
Risk is hedged, not naked
There is still spare capital available
The setup can later be automated more easily because the rules are defined

Understanding the Payoff Profile

In the example setup:

Maximum profit: about ₹4,000
Maximum loss: about ₹21,000
Probability of profit: about 80%

That 80% figure is the reason this strategy is framed as a probability based setup. If we repeatedly take trades with similar conditions, we are aiming for a structure where most trades work and a smaller number of trades fail.

This does not mean every trade will win. It means the setup is designed so that the odds are tilted in our favour over a series of trades.

Why Delta Matters So Much

The confidence behind the 80% plus probability of profit comes directly from the delta we choose to sell.

Here is the rough idea:

0.20 delta gives a profit probability of roughly 80% or more
0.30 delta drops it closer to 70%
0.40 delta brings it near 60%
At the money options move toward a 50% style probability profile

This is why the strategy specifically uses the 0.20 delta for the short option. We are intentionally choosing a strike that gives a better chance of winning, even if that means the profit per trade is not very large.

That is an important mindset shift. We are not trying to maximize reward on each trade. We are trying to build a repeatable setup where the probability profile works in our favour.

Risk Management is the Most Important Part

Without risk management, option selling can become dangerous very quickly. A strategy may look safe because of its high probability, but if losses are left uncontrolled, one bad trade can erase many good ones.

That is why this setup defines both target and stop loss very clearly.

The risk management rule

Both target and stop loss are set at 70% of maximum profit .

Using the example:

Maximum profit = ₹4,000
70% of max profit = ₹2,800

So the trade rules become:

Book profit at ₹2,800
Exit at ₹2,800 loss

This gives a 1:1 risk to reward structure in actual execution, even though the full payoff graph may show a different maximum profit and maximum loss.

Why Book Profit at 70% of Maximum Profit?

This is where many traders make mistakes. They see that the strategy can theoretically earn ₹4,000, so they try to hold till the absolute maximum.

That usually is not worth it.

Once the position has already made around ₹2,800, a large part of the available profit has already been captured. From there, the extra gain left on the table is only about ₹1,200 in this example.

Keeping the trade open for that comparatively small remaining gain does not make much sense, especially in option selling where risk can change quickly.

So when a trade has already delivered around 60% to 70% of its possible best case profit, it is often smarter to close it, lock the gains, and move on. There will always be another trading day and another setup.

Why Stop the Trade at the Same ₹2,800 Loss?

The same discipline applies on the downside.

If the position reaches a loss of ₹2,800, we close it. We do not wait and hope.

Why? Because the total defined loss on the structure can be far larger. In the example, the maximum possible loss is more than ₹21,000. If we allow the trade to continue after the setup has already proven itself wrong, we expose the account to a much bigger drawdown.

So the stop loss is not arbitrary. It is there to prevent a manageable loss from becoming a damaging one.

In short:

If the trade makes ₹2,800, we exit.
If the trade loses ₹2,800, we also exit.
We stop trading that setup for the day and return fresh on the next opportunity.

Markets open every day. Opportunities do not disappear. Capital discipline matters more than forcing one trade to work.

This Strategy is Based on Probability, Not Huge Risk Reward

A lot of traders get obsessed with risk to reward alone. This strategy takes a different route.

Here, the edge does not come from chasing a 1:3 or 1:5 reward profile. The edge comes from taking a setup that is designed to win a high percentage of the time, while keeping individual losses controlled.

That is why the framework is built around:

** High probability entries*

Delta based strike selection
Defined hedging
Equal target and stop loss based on 70% of max profit

This is a different style of trading. We are playing the odds over a series of trades, not trying to hit one oversized winner.

The Full DOS Setup at a Glance

Entry conditions

Use Supertrend 10/3
Use 5 minute timeframe for intraday execution
Green Supertrend means bullish bias
Red Supertrend means bearish bias

Bullish trade

Sell the put with delta near 0.20
Buy the put with delta near 0.10 as hedge

Bearish trade

Sell the call with delta near 0.20
Buy the call with delta near 0.10 as hedge

Capital and probability

Capital required is generally less than ₹1 lakh
Probability of profit is designed to be greater than 80%

Exit rules

Target = 70% of max profit
Stop loss = 70% of max profit

Before Automating, Trade It Manually First

It is tempting to jump straight into algo trading, but that is usually the wrong sequence.

Before building automation, we should first understand how the strategy behaves in real market conditions. That means:

Manually backtesting the idea on historical charts
Applying it to current market sessions
Paper trading it before deploying real capital

This step builds intuition. We start understanding how often the signal appears, how the position reacts, how the exits feel, and whether the rules are practical to follow.

Only after gaining this experience does it make sense to automate the logic.

How the Algo Version Works

Once the strategy rules are clear, this setup is quite suitable for automation.

The algo logic is straightforward:

Check market direction using the predefined signal.
Pull the option chain.
Identify whether we need calls or puts based on the direction.
Find the strike with delta nearest to 0.20 for selling.
Find the strike with delta nearest to 0.10 for hedging.
Use those strikes to place the order structure.

For example, if the signal is bearish, the algo goes into the call option chain, searches for the call whose delta is closest to 0.20, and marks that as the short strike. Then it looks for the call whose delta is closest to 0.10 and marks that as the hedge strike.

That is the essence of delta based strike selection in an automated trading system.

What the Strategy Teaches About Algo Trading

This setup is a good starting point for algorithmic trading because it highlights the foundations of a proper trading system:

A clear entry condition
A repeatable strike selection rule
Defined capital usage
Preplanned exits
A structure that can be backtested and automated

That is exactly how beginners should think about small capital algo trading. Not as a shortcut, but as a process of converting a manual edge into a systematic one.

Final Takeaway

If we want to start algo trading with ₹1 lakh capital, we do not need a highly complex system. We need a disciplined one.

DOS, or Directional Option Selling, offers a simple framework:

Use Supertrend to define direction
Sell the 0.20 delta option
Hedge with the 0.10 delta option
Keep capital usage below ₹1 lakh
Target a high probability setup
Exit at 70% of max profit on both the upside and downside

From there, the right next step is not to rush into full automation. The right next step is to backtest it, paper trade it, and understand how it behaves. Once we have that experience, building the algo becomes far more meaningful and far more practical.

Made with - Start Algo Trading with ₹1 Lakh Capital | Complete Strategy Explained

SUPERNOVA · June 18, 2026, 10:33am

Instead of options , i wish to do in ETF

would appreciate your guidance on whether this can be implemented using Dhan Algo and, if yes, how to configure it.

My objective is to create a basic buy-and-sell loop using limit orders.

For example:

ETF CMP = ₹23.00
Quantity per order = 1000 units
Buy Gap = ₹0.10
Sell Gap = ₹0.30

Once a sell order is completed, I would like the system to automatically place the original buy order again at the same level, thereby creating a continuous or infinite trading loop.

CAn you please guide me how to set up this .

Tradehull_Imran · June 18, 2026, 5:42pm

Hi @SUPERNOVA ,

Yes, this can be implemented. The logic would involve placing a buy limit order at the desired level, followed by a sell limit order once the buy order is executed. After the sell order is completed, the system can automatically place the original buy order again, thereby creating a continuous trading loop based on the defined buy and sell gaps.

Do run the command on the cmd terminal -

pip install dhanhq==2.2.0
pip install Dhan-Tradehull==3.3.1

Refer the sample code -

import time
from Dhan_Tradehull import Tradehull

client_code = ""
tsl = Tradehull(client_code, mode="pin_totp", pin="", totp_secret="")

SYMBOL = "SILVERBEES"
EXCHANGE = "NSE"
QTY = 1000
CMP = 23.00
BUY_PRICE = round(CMP - 0.10, 2)
SELL_PRICE = round(BUY_PRICE + 0.30, 2)

while True:
    buy_order_id = tsl.order_placement(SYMBOL, EXCHANGE, QTY, BUY_PRICE, 0, "LIMIT", "BUY", "CNC", validity="DAY")
    print("BUY Order Placed:", buy_order_id, "Price:", BUY_PRICE)

    while True:
        buy_status = str(tsl.get_order_status(buy_order_id)).upper()
        print("BUY Status:", buy_status)

        if buy_status == "TRADED":
            break
        if buy_status in ["REJECTED", "CANCELLED"]:
            print("BUY order failed. Stopping loop.")
            exit()

        time.sleep(1)

    sell_order_id = tsl.order_placement(SYMBOL, EXCHANGE, QTY, SELL_PRICE, 0, "LIMIT", "SELL", "CNC", validity="DAY")
    print("SELL Order Placed:", sell_order_id, "Price:", SELL_PRICE)

    while True:
        sell_status = str(tsl.get_order_status(sell_order_id)).upper()
        print("SELL Status:", sell_status)

        if sell_status == "TRADED":
            break
        if sell_status in ["REJECTED", "CANCELLED"]:
            print("SELL order failed. Stopping loop.")
            exit()

        time.sleep(1)

    print("SELL completed. Repeating BUY again at same price:", BUY_PRICE)

SUPERNOVA · June 19, 2026, 2:53am

Thanks Sir for your prompt guidance . I have following queries if you will be kind enough to take them

I couldnt properly ask my query earlier . Actually my strategy was to start algo when LTP reaches 23 . cmp may be 23 + anything .
As LTP = 23 , Algo starts and the first bought 1000 qty quantities gets sold at 23.9 . BUt in case the price moves down then following thing happens .

	BUYING GAP	0.1
	SELLING GAP	0.3
	QUANTITY	1000
QUANTITY
1000	BUY @	22.90	SELL @	23.20
1000		22.80		23.10
1000		22.70		23.00
1000		22.60		22.90
1000		22.50		22.80

and i give command till how many low it will go like it goes till 10 times more down each time 0.1 like that .

i dont use any stop loss .

Tradehull_Imran · June 19, 2026, 4:12am

Hi @SUPERNOVA ,

Yes, this is possible with simple LTP-based grid logic. Algo will start when LTP reaches 23, then it will place the first buy order. If price goes up, it will exit at 23.90. If price comes down, it will keep buying every 0.10 gap and sell each buy level with 0.30 profit gap. Number of downside levels can be controlled by one variable.

Refer the sample code -

import time
from Dhan_Tradehull import Tradehull   

client_code = ""
tsl = Tradehull(client_code, mode="pin_totp", pin="", totp_secret="")

SYMBOL = "ABC"
EXCHANGE = "NSE"
PRODUCT = "MIS"

START_PRICE = 23.00
FIRST_QTY = 1000
FIRST_EXIT = 23.90

BUYING_GAP = 0.10
SELLING_GAP = 0.30
QTY = 1000
TOTAL_LEVELS = 10

POLL_SECONDS = 1

algo_started = False
first_buy_done = False
first_sell_done = False

grid = []

for i in range(1, TOTAL_LEVELS + 1):
    buy_price = round(START_PRICE - BUYING_GAP * i, 2)
    sell_price = round(buy_price + SELLING_GAP, 2)
    grid.append({"buy_price": buy_price, "sell_price": sell_price, "qty": QTY, "bought": False, "sold": False, "buy_order_id": None, "sell_order_id": None})

print("Grid Created")
for row in grid:
    print(row)

while True:
    try:
        ltp_data = tsl.get_ltp_data(SYMBOL)
        ltp = ltp_data.get(SYMBOL)

        if ltp is None:
            print("LTP not found")
            time.sleep(POLL_SECONDS)
            continue

        ltp = round(float(ltp), 2)
        print("LTP:", ltp)

        if not algo_started and ltp >= START_PRICE:
            algo_started = True
            buy_order_id = tsl.order_placement(tradingsymbol=SYMBOL, exchange=EXCHANGE, quantity=FIRST_QTY, price=0, trigger_price=0, order_type="MARKET", transaction_type="BUY", trade_type=PRODUCT)
            first_buy_done = True
            print("First BUY placed:", buy_order_id)

        if algo_started and first_buy_done and not first_sell_done and ltp >= FIRST_EXIT:
            sell_order_id = tsl.order_placement(tradingsymbol=SYMBOL, exchange=EXCHANGE, quantity=FIRST_QTY, price=0, trigger_price=0, order_type="MARKET", transaction_type="SELL", trade_type=PRODUCT)
            first_sell_done = True
            print("First SELL placed:", sell_order_id)

        for row in grid:
            if not row["bought"] and ltp <= row["buy_price"]:
                order_id = tsl.order_placement(tradingsymbol=SYMBOL, exchange=EXCHANGE, quantity=row["qty"], price=0, trigger_price=0, order_type="MARKET", transaction_type="BUY", trade_type=PRODUCT)
                row["bought"] = True
                row["buy_order_id"] = order_id
                print(f"Grid BUY @ {row['buy_price']} | Order ID: {order_id}")

            if row["bought"] and not row["sold"] and ltp >= row["sell_price"]:
                order_id = tsl.order_placement(tradingsymbol=SYMBOL, exchange=EXCHANGE, quantity=row["qty"], price=0, trigger_price=0, order_type="MARKET", transaction_type="SELL", trade_type=PRODUCT)
                row["sold"] = True
                row["sell_order_id"] = order_id
                print(f"Grid SELL @ {row['sell_price']} | Order ID: {order_id}")

        time.sleep(POLL_SECONDS)

    except Exception as e:
        print("Error:", e)
        time.sleep(POLL_SECONDS)

SUPERNOVA · June 19, 2026, 5:13am

Thanks a lot . You are a Rockstar