Algorithmic Trading

Distinguish NSE and BSE trading sessions, market segments, holidays, and auction sessions relevant to equity swing trading.

Map tradingsymbols, exchanges, and instrument tokens using the Zerodha instrument master.

Select appropriate Kite order varieties, order types, product codes, and validity settings for delivery trades.

Calculate the cash and margin impact of a representative Indian equity delivery trade.

Calculate brokerage, STT, exchange charges, GST, stamp duty, and SEBI charges for a trade.

Explain how settlement, short delivery, corporate actions, and price bands can affect a swing position.

Trace the Zerodha Kite authentication flow and the lifecycle of a data or order request.

Identify broker and exchange constraints on API rate limits, data access, and unattended automation.

Calculate arithmetic and log returns and aggregate them across holding periods.

Estimate sample mean, variance, standard deviation, and quantiles from return data.

Construct and interpret a confidence interval for an estimated average return.

Measure skewness and kurtosis and explain why fat-tailed returns affect trading risk.

Calculate covariance and correlation and interpret their role in diversification.

Fit an ordinary least-squares model and interpret coefficients and residuals in a market context.

Detect serial correlation in a return series using an autocorrelation function and the Ljung–Box test.

Interpret a hypothesis-test result without confusing statistical significance with economic usefulness.

Design separate raw, cleaned, and feature-ready data layers for reproducible research.

Build a versioned mapping between Indian stock symbols and Zerodha instrument tokens.

Implement an incremental Kite historical-data downloader that respects date-window and rate-limit constraints.

Normalize timestamps and retain only valid exchange sessions using an Indian market calendar.

Detect missing bars, duplicate bars, stale prices, and implausible OHLCV values.

Account for splits, bonuses, dividends, symbol changes, and delistings without introducing look-ahead bias.

Store partitioned historical data in Parquet and query it efficiently with DuckDB.

Record data-source, retrieval-time, adjustment, and validation metadata for each dataset snapshot.

Convert a market intuition into a falsifiable strategy hypothesis with a stated economic rationale.

Define a liquid, tradable stock universe using point-in-time information.

Calculate momentum, moving-average, volatility, and average-true-range features from lagged data.

Construct a cross-sectional ranking signal for selecting swing-trade candidates.

Specify deterministic entry, exit, holding-period, and rebalancing rules.

Define benchmark and no-skill baselines against which to compare the strategy.

Visualize signals and proposed trades on price charts to identify implementation errors.

Represent the complete strategy specification as parameterized, executable rules.

Define data, signal, order, fill, position, and portfolio interfaces for an event-driven backtester.

Encode close-to-next-session execution timing without using unavailable future information.

Maintain a cash, position, and average-cost ledger across multiple stocks.

Simulate market and limit order fills using explicit fill assumptions.

Deduct Indian transaction charges, slippage, and liquidity-dependent impact from simulated fills.

Generate an auditable order, fill, trade, and daily-equity record from a backtest.

Calculate CAGR, volatility, Sharpe ratio, maximum drawdown, hit rate, payoff ratio, and turnover.

Reconcile a small backtest against hand-calculated expected positions, cash, costs, and P&L.

Partition time-series data into chronological development, validation, and untouched test periods.

Run an expanding-window or rolling-window walk-forward evaluation.

Evaluate parameter sensitivity with a structured grid rather than selecting a single best result.

Detect common forms of look-ahead, survivorship, selection, and data-snooping bias in a research result.

Use bootstrap resampling to estimate uncertainty in a strategy performance statistic.

Compare strategy behavior across bull, bear, volatile, and quiet market regimes.

Stress-test performance under worse costs, delayed fills, missing signals, and price gaps.

Define quantitative acceptance criteria before examining final out-of-sample results.

Translate ranked strategy signals into target portfolio positions.

Size positions using a volatility target and a maximum-capital constraint.

Calculate volatility- or ATR-based exits while accounting for overnight gap risk.

Enforce single-stock, sector, gross-exposure, turnover, and liquidity limits.

Estimate portfolio covariance and each position’s contribution to total risk.

Model cash availability and turnover during portfolio rebalancing.

Define drawdown, stale-data, and abnormal-loss circuit breakers.

Evaluate portfolio return, risk, concentration, and capacity against explicit limits.

Implement an authenticated Kite client that keeps credentials and access tokens out of source code.

Convert target portfolio differences into a deterministic order plan.

Choose between market and limit orders based on urgency, spread, and liquidity.

Apply pre-trade checks for capital, quantity, price bands, liquidity, and portfolio limits.

Model each order with an explicit pending, open, partial, filled, cancelled, or rejected state.

Make order submission idempotent so retries cannot create unintended duplicate exposure.

Handle partial fills, rejections, timeouts, and cancel-replace decisions.

Reconcile internal orders and positions with Kite’s order book, trade book, holdings, and positions.

Partition the system into components with explicit interfaces and failure boundaries.

Design persistent schemas for signals, target positions, orders, fills, portfolio snapshots, and job runs.

Load environment-specific configuration and secrets securely at runtime.

Schedule jobs against Indian exchange sessions and holidays without duplicate runs.

Emit structured logs with identifiers that trace a decision from signal through fill.

Define operational metrics and alerts for stale data, failed jobs, rejected orders, and position mismatches.

Apply bounded retries, timeouts, backoff, and API rate limiting to external calls.

Package and deploy the trading application as a versioned containerized service.

Implement a simulated broker adapter behind the same interface as the Kite execution adapter.

Run the complete daily workflow in shadow mode using current market data without placing orders.

Compare paper-trading signals, orders, fills, costs, and positions with backtest expectations.

Rehearse recovery from stale data, API downtime, process restarts, duplicate triggers, and ambiguous orders.

Create a daily operating runbook and a deployment-readiness checklist.

Reconcile end-of-day positions, cash, P&L, and charges against broker records.

Stage a small-capital rollout with strict exposure caps, order caps, alerts, and a manual kill switch.

Conduct post-trade reviews and convert operational incidents into tests or safeguards.

Explain how spread, queue position, market impact, and latency matter more for intraday systems.

Consume Kite WebSocket ticks with reconnect, resubscription, heartbeat, and deduplication handling.

Aggregate validated ticks into deterministic intraday bars.

Process market-data and order events through an asynchronous event loop without blocking.

Measure end-to-end decision latency and detect clock or feed staleness.

Model intraday slippage, partial fills, and transaction costs at the intended trading frequency.

Backtest intraday bars with session boundaries and execution timing that prevent leakage.

Define the data, execution, risk, and operational criteria required before migrating a swing system to intraday trading.