Cash-Market Algo Trading Income System (NIFTY 500, Upstox API)

 Executive Summary: This blueprint delivers a comprehensive framework for systematic equity trading in NSE NIFTY 500 stocks using Upstox API automation. The system prioritizes consistent income generation through 8 proven quant strategies, validated backtesting protocols, and a phased deployment approach scaling from ₹2-10 lakh capital.Machine-Trading_-Deploying-Computer-Algorithms-to-Conquer-the-Markets-PDFDrive.pdfojs.aut+1

Strategy Universe Ranking

Based on historical robustness, implementation feasibility, and income consistency across market regimes:

Rank	Strategy	Win Rate	Regime Fit	Capacity	Implementation
1	VWAP Mean Reversion	65%	Intraday Range	High	Moderate
2	Opening Range Breakout (ORB)	58%	Trending Days	High	Simple
3	RSI Mean Reversion	62%	Sideways Markets	High	Simple
4	Bollinger Band Pullback	55%	All Regimes	High	Moderate
5	EMA Crossover Trend	53%	Trending Markets	High	Simple
6	Statistical Pairs Trading	72%	All Regimes	Medium	Complex
7	Gap Trading System	48%	Earnings/News	Medium	Moderate
8	Volume-Volatility Expansion	51%	Breakout Events	Medium	Complex

Detailed Strategy Cards

1. VWAP Mean Reversion Strategy

Name & Regime: VWAP Mean Reversion — Intraday Range-bound Markets
Objective: Capture intraday mean reversion around VWAP anchor
Edge: Stock prices tend to revert to VWAP during normal trading sessionsMachine-Trading_-Deploying-Computer-Algorithms-to-Conquer-the-Markets-PDFDrive.pdf

Entry Logic:

• Price deviation from VWAP > 1.5 standard deviations

• Volume > 1.2x 20-day average volume

• No major news/earnings within 2 days

• Time window: 10:00 AM - 2:30 PM IST

Exit Logic:

• Target: 0.8x standard deviation from VWAP

• Stop Loss: 2.5x standard deviation from VWAP

• Time Exit: 3:15 PM (mandatory square-off)

Position Sizing: 2% capital per trade, max 8 concurrent positions
Data Requirements: 1-minute OHLCV, real-time VWAP calculation
Expected Performance: 15-20% annual return, 0.8-1.2 Sharpe ratio

2. Opening Range Breakout (ORB)

Name & Regime: ORB Momentum — Strong Trending Days
Objective: Capture momentum from first 15-minute range breakouts
Edge: Initial price action sets daily directional biasMachine-Trading_-Deploying-Computer-Algorithms-to-Conquer-the-Markets-PDFDrive.pdf

Entry Logic:

• Define 9:15-9:30 AM high/low as range

• Enter long on breakout above range high + 0.1%

• Enter short on breakdown below range low - 0.1%

• Volume confirmation: >150% of 10-day average

Exit Logic:

• Target: 1.5x range width

• Stop Loss: Opposite range boundary

• Trailing stop: 50% of peak profit

Position Sizing: 1.5% capital per trade, max 5 concurrent positions
Liquidity Filter: Only NIFTY 500 stocks with >₹50 crore daily turnoverniftyindices

Manual Implementation Plan

Top 3 Strategy Manual Execution

Phase 1: VWAP Mean Reversion (Manual)

1. Pre-Market Setup (9:00-9:15 AM):

   • Screen NIFTY 500 for volume >1.2x average

   • Calculate previous day's VWAP and standard deviation

   • Set up watchlist of 20-30 liquid stocks

2. Trade Execution Checklist:

   • Monitor real-time VWAP deviation on charting platform

   • Place bracket orders: Entry + SL + Target

   • Position size = (Account Value × 0.02) ÷ Stop Loss Distance

   • Maximum 8 trades per day

3. Risk Management:

   • Daily loss limit: 1% of account value

   • Single trade risk: 0.25% of account value

   • Maintain trade journal in Excel/Google Sheets

Phase 2: ORB Manual Implementation

1. Morning Routine:

   • Identify overnight gap stocks (>±2%)

   • Mark 9:15-9:30 range on charts

   • Set alerts for breakout levels

2. Execution Protocol:

   • Wait for volume confirmation before entry

   • Use stop-loss orders mandatory

   • Track 5 positions maximum simultaneously

Algo Implementation Blueprint (Upstox API)

Tech Stack Architecture

text
Language: Python 3.9+
Core Libraries: upstox-python-sdk, pandas, numpy, ta-lib
Execution: REST API (orders) + WebSocket (live data)  
Database: SQLite for logs, Redis for real-time data
Scheduling: APScheduler for signal generation
Monitoring: Custom dashboard + SMS alerts

Core Implementation Framework

1. Signal Generation Module

python
import pandas as pd
import numpy as np
from ta import add_all_ta_features
import upstox_client

class VWAPMeanReversionStrategy:
    def __init__(self, api_client):
        self.client = api_client
        self.lookback_period = 20
        self.deviation_threshold = 1.5
        
    def calculate_signals(self, symbol, df):
        """Generate VWAP mean reversion signals"""
        # Calculate VWAP and rolling statistics
        df['vwap'] = (df['close'] * df['volume']).cumsum() / df['volume'].cumsum()
        df['price_deviation'] = (df['close'] - df['vwap']) / df['vwap']
        df['rolling_std'] = df['price_deviation'].rolling(self.lookback_period).std()
        
        # Generate signals
        df['signal'] = 0
        df.loc[df['price_deviation'] > self.deviation_threshold * df['rolling_std'], 'signal'] = -1  # Short
        df.loc[df['price_deviation'] < -self.deviation_threshold * df['rolling_std'], 'signal'] = 1   # Long
        
        return df

2. Order Management Module

python
class OrderManager:
    def __init__(self, api_client, max_positions=8, risk_per_trade=0.02):
        self.client = api_client
        self.max_positions = max_positions
        self.risk_per_trade = risk_per_trade
        
    def place_bracket_order(self, symbol, signal, current_price, account_value):
        """Place bracket order with SL and Target"""
        position_size = self.calculate_position_size(current_price, account_value)
        
        if signal == 1:  # Long position
            sl_price = current_price * 0.985  # 1.5% stop loss
            target_price = current_price * 1.012  # 1.2% target
            side = 'BUY'
        else:  # Short position
            sl_price = current_price * 1.015
            target_price = current_price * 0.988
            side = 'SELL'
            
        # Place main order
        order_request = {
            'symbol': symbol,
            'quantity': position_size,
            'price': current_price,
            'side': side,
            'order_type': 'LIMIT',
            'product': 'MIS'  # Intraday
        }
        
        return self.client.place_order(order_request)

3. Risk Management Module

python
class RiskManager:
    def __init__(self, max_daily_loss=0.01, max_portfolio_risk=0.08):
        self.max_daily_loss = max_daily_loss
        self.max_portfolio_risk = max_portfolio_risk
        self.daily_pnl = 0
        
    def check_risk_limits(self, account_value, open_positions):
        """Validate if new trade is within risk limits"""
        # Check daily loss limit
        if abs(self.daily_pnl) > self.max_daily_loss * account_value:
            return False, "Daily loss limit exceeded"
            
        # Check portfolio risk
        total_risk = sum([pos['risk_amount'] for pos in open_positions])
        if total_risk > self.max_portfolio_risk * account_value:
            return False, "Portfolio risk limit exceeded"
            
        return True, "OK"

Backtesting Framework

Data Requirements

python
# Required data for NIFTY 500 backtesting
data_requirements = {
    'timeframes': ['1min', '5min', '1day'],
    'fields': ['open', 'high', 'low', 'close', 'volume'],
    'lookback': '2 years',
    'corporate_actions': True,
    'liquidity_filter': 'min_turnover_50cr'
}

Backtest Engine Sample

python
import vectorbt as vbt
from datetime import datetime, timedelta

class BacktestEngine:
    def __init__(self, strategy_class, universe, start_date, end_date):
        self.strategy = strategy_class
        self.universe = universe
        self.start_date = start_date
        self.end_date = end_date
        
    def run_backtest(self, initial_capital=500000):
        """Run comprehensive backtest with transaction costs"""
        results = {}
        
        for symbol in self.universe:
            # Load data
            data = self.load_stock_data(symbol)
            
            # Generate signals
            signals = self.strategy.calculate_signals(symbol, data)
            
            # Apply transaction costs (0.1% for Indian equities)
            pf = vbt.Portfolio.from_signals(
                data['close'], 
                signals['signal'] == 1,  # entries
                signals['signal'] == -1,  # exits
                fees=0.001,  # 0.1% transaction cost
                freq='1min'
            )
            
            results[symbol] = {
                'total_return': pf.total_return(),
                'sharpe_ratio': pf.sharpe_ratio(),
                'max_drawdown': pf.max_drawdown(),
                'win_rate': pf.win_rate(),
                'trades_count': pf.orders.count()
            }
            
        return self.aggregate_results(results)

Model Validation Protocol

Walk-Forward Analysis

python
def walk_forward_validation(strategy, data, train_periods=252, test_periods=63):
    """Rolling window validation for strategy robustness"""
    results = []
    
    for start in range(train_periods, len(data) - test_periods, test_periods):
        train_data = data.iloc[start-train_periods:start]
        test_data = data.iloc[start:start+test_periods]
        
        # Train strategy parameters
        strategy.optimize_parameters(train_data)
        
        # Test on out-of-sample data
        test_results = strategy.backtest(test_data)
        results.append(test_results)
        
    return pd.DataFrame(results)

Portfolio & Risk Management

Capital Allocation Framework

• Conservative: Single trade risk ≤1%, portfolio risk ≤5%

• Moderate: Single trade risk ≤2%, portfolio risk ≤8%

• Aggressive: Single trade risk ≤3%, portfolio risk ≤12%

Risk Controls

python
RISK_PARAMETERS = {
    'max_daily_loss': 0.01,  # 1% of account value
    'max_positions': 8,
    'max_sector_exposure': 0.3,  # 30% in any sector
    'correlation_limit': 0.7,  # Max correlation between positions
    'volatility_limit': 0.25  # Max position volatility (annualized)
}

Automated Risk Monitoring

• Real-time P&L tracking with SMS alerts

• Automatic position flattening at risk limits

• End-of-day risk report generation

• Weekly strategy performance review

###sed Implementation Plan

Phase 1: Infrastructure & Backtesting (Days 1-30)

Deliverables:

• Complete data pipeline setup

• Backtesting framework validation

• Strategy parameter optimization

• Risk management system testing

Success Metrics:

• All 8 strategies showing positive expectancy

• Transaction cost models validated

• Risk systems tested under stress scenarios

Phase 2: Paper Trading (Days 31-90)

Deliverables:

• Live paper trading with Upstox API

• Real-time signal generation

• Order management system testing

• Performance monitoring dashboard

Success Metrics:

• Paper trading P&L matches backtest within 5%

• Zero system downtime during market hours

• All risk limits functioning correctly

Phase 3: Small Capital Deployment (Days 91-180)

Deliverables:

• Live trading with ₹1-2 lakh capital

• Top 3 strategies deployment

• Daily performance monitoring

• Risk adjustment protocols

Success Metrics:

• Daily Sharpe ratio >0.5

• Maximum daily loss <1%

• Win rate >55% for mean reversion strategies

Phase 4: Full-Scale Automation (Days 181-365)

Deliverables:

• All 8 strategies live deployment

• Portfolio optimization algorithms

• Advanced risk management

• Performance attribution system

Success Metrics:

• Annual return target: 18-25%

• Maximum drawdown <8%

• Sustained Sharpe ratio >1.2

Upstox API Integration Details

Authentication & Setup

python
import upstox_client

# Initialize API client
configuration = upstox_client.Configuration()
configuration.access_token = "YOUR_ACCESS_TOKEN"
api_client = upstox_client.ApiClient(configuration)

# Setup API instances
order_api = upstox_client.OrderApi(api_client)
market_data_api = upstox_client.MarketDataApi(api_client)
portfolio_api = upstox_client.PortfolioApi(api_client)

Live Data Streaming

python
import websocket
import json

def on_message(ws, message):
    """Process real-time market data"""
    data = json.loads(message)
    symbol = data['symbol']
    ltp = data['ltp']
    
    # Update strategy signals
    strategy_signal = strategy.update_signal(symbol, ltp)
    
    # Execute trades if signal generated
    if strategy_signal:
        execute_trade(symbol, strategy_signal)

# WebSocket connection
ws_url = "wss://api.upstox.com/v2/feed/market-data-feed"
ws = websocket.WebSocketApp(ws_url, on_message=on_message)

The framework provides a robust foundation for systematic equity trading in Indian markets, emphasizing risk management, consistent income generation, and scalable automation through the Upstox API platform.ojs.aut+1Machine-Trading_-Deploying-Computer-Algorithms-to-Conquer-the-Markets-PDFDrive.pdf

Educational use only. Not investment advice. Backtest and validate before live trading. Market conditions and regulations change; consult authorized financial advisors and verify with NSE/SEBI guidelines before execution.