DeltaForge: Building an Autonomous Options Trading System

I trade Nifty 50 options intraday. Like most retail traders, I had a strategy that backtested beautifully but bled money in production. The problem was never the strategy. It was me. Late entries because I was in a meeting. Emotional exits because a candle looked scary. Position sizing that fluctuated with confidence rather than math.

The tools available were either overpriced terminals (₹2K-15K/month) that couldn't be customized, or fragile scripts taped together with cron jobs and prayers. I wanted something different: a production-grade system where I define the rules once, and the machine executes them with zero emotion, every single session. So I built one.

"Stop watching charts. Start trading systems."

DeltaForge is a pipeline, not unlike a CI/CD system, but for money. Market data flows in from the left, passes through strategy evaluation, risk filtering, and position management, then exits as either an executed trade or a rejected signal.

A single strategy is brittle. Markets are regime-dependent: what works in trending days fails on mean-reversion days. DeltaForge runs five strategies in parallel, each generating a signal with a confidence score. The engine picks the highest-confidence signal above threshold.

class MultiStrategyEngine:
    strategies = [
        StochasticCross(),
        PullbackInTrend(),
        SupertrendFlip(),
        VWAPBias(),
        RSIMeanReversion(),
    ]

    def evaluate(self, candle: OHLCV) -> Signal | None:
        # Run all strategies in parallel, pick highest confidence
        signals = [s.check(candle) for s in self.strategies]
        valid = [s for s in signals if s and s.confidence >= 50]
        return max(valid, key=lambda s: s.confidence, default=None)

This is the part that actually matters. A strategy that's 55% accurate with rigorous risk management will outperform a 75% strategy with none. Every signal must pass through all nine gates sequentially. A single failure means the trade is either rejected (signal skipped) or the system halts entirely.

The key distinction: Reject means the signal is skipped but trading continues. HALT means the system stops for the entire session. Gates 1-5 trigger halts because they indicate something structurally wrong: you're losing too much money and need to stop.

class RiskEngine:
    # 9 gates - every signal must pass ALL before execution

    def check_gates(self, signal: Signal) -> GateResult:
        gates = [
            self._gate_system_active,       # 0: not halted
            self._gate_min_capital,          # 1: capital >= ₹3,000
            self._gate_daily_loss,           # 2: daily loss < 25%
            self._gate_weekly_loss,          # 3: weekly loss < 50%
            self._gate_consecutive_losses,   # 4: streak < 5
            self._gate_drawdown,             # 5: drawdown < 35%
            self._gate_vix,                  # 5.5: VIX ≤ 18
            self._gate_expiry_day,           # 6: not expiry
            self._gate_entry_window,         # 7: within hours
            self._gate_confidence,           # 8: conf ≥ 50
        ]
        for gate in gates:
            result = gate(signal)
            if not result.passed:
                return result  # REJECT or HALT
        return GateResult(passed=True)

Fixed lot sizing leaves money on the table when you're winning and amplifies losses when you're not. DeltaForge uses compound position sizing that scales with your equity curve, but throttles aggressively during drawdowns.

Most trading systems have a dirty secret: the backtest code and the live code are different. Different indicator calculations, different order logic, different assumptions. You validate a strategy in backtest, deploy it live, and it behaves differently. DeltaForge eliminates this by using the exact same engine across all modes.

The only difference between modes is what happens after the position manager decides to trade: paper mode simulates the fill with a realistic premium model (brokerage ₹20/order + STT + stamp duty + ₹1.5 slippage), while live mode hits the Angel One SmartAPI.

$ df trade

[09:15:01] Engine started in PAPER mode
[09:15:02] WebSocket connected - streaming Nifty ticks
[09:22:15] SIGNAL  Stochastic Cross  BUY  conf=72
[09:22:15] RISK    9/9 gates passed
[09:22:16] ENTRY   NIFTY 24500 CE @ ₹185.40  qty=50
[10:14:33] EXIT    ₹213.20  P&L +₹1,390  (+15.0%)
[15:30:00] EOD     3 trades | Net P&L +₹3,820 | Capital ₹13,820

An autonomous trading system without a kill switch is a ticking bomb. DeltaForge's kill switch is an independent watchdog process, completely separate from the main trading engine. If the engine hangs, crashes, or enters an infinite loop, the kill switch still works.

Why file-based? Because it works even when the main process is hung. No IPC, no shared memory, no sockets. Just a file on disk. If the file exists, trading stops. Period. The risk engine checks it before every gate evaluation.

Building DeltaForge taught me things no blog post or course ever could. Here's what I'd tell anyone building a similar system: