Understand algorithmic trading fundamentals — Stock-Market notes

What is Algorithmic Trading?

Why it exists: Human traders face three fundamental limitations:

Speed: Milliseconds matter when opportunities appear and disappear
Consistency: Emotions cause deviation from optimal strategy
Scale: Monitoring thousands of securities simultaneously is impossible manually

How it works: You translate a trading hypothesis into precise rules → code these rules → the program monitors markets → when conditions match, it executes trades automatically.

The Three Pillars of Algo Trading

1. Signal Generation (The "Why Trade" Decision)

What: The logic that identifies trading opportunities.

How it's built: You define conditions that must be true:

Technical signals: Moving average crossover, RSI oversold/overbought, breakout from range
Fundamental signals: P/E ratio below industry average, earnings surprise >10%
Statistical signals: Price deviation from mean by 2 standard deviations (mean reversion)
Market microstructure: Order book imbalance, bid-ask spread anomalies

Why this matters: Without a valid signal, you're just randomly executing trades. The signal is your edge—your hypothesis about what price pattern predicts future movement.

Worked example Signal Example: Moving Average Crossover

Strategy: Buy when 50-day MA crosses above 200-day MA (bullish signal), sell when it crosses below.

The logic:

Short-term average > long-term average → recent momentum is upward → trend shift to bullish
This captures "the trend is your friend" systematically Why this step?

Calculate 50-day MA: $MA_{50} = \frac{1}{50}\sum_{i=0}^{49} P_{t-i}$ (average of last 50 closes)
Calculate 200-day MA: $MA_{200} = \frac{1}{200}\sum_{i=0}^{199} P_{t-i}$
Check if $MA_{50,t} > MA_{200,t}$ AND $MA_{50,t-1} \leq MA_{200,t-1}$ (crossover just happened)
If true → Generate BUY signal Why the "just happened" check? Without it, you'd get a BUY signal every single day the 50-day is above 200-day. You only want to act on the transition.

2. Risk Management (The "How Much" Decision)

What: Rules that determine position size and when to exit (stop-loss, take-profit).

Why it's critical: A profitable signal can still destroy your account if you risk too much per trade. Risk management ensures survival during losing streaks.

How: You set parameters before the trade:

$\text{Position Size} = \frac{\text{Risk Capital per Trade}}{\text{Risk per Share}}$

Where:

Risk Capital per Trade = Account Size × Risk % (typically 1-2% of account)
Risk per Share = Entry Price - Stop Loss Price

Derivation:

If your account is $100{,}000 \text{ and you risk } 1\% \text{ per trade} \rightarrow \text{Risk Capital} =$ 1,000
If you buy at $50 with stop-loss at$ 48 → Risk per Share = $2
Position Size = $1,000 /$ 2 = 500 shares
Why this formula? It guarantees that if stopped out, you lose exactly $1,000 (500 shares ×$ 2 loss per share), which is your predetermined1% risk.

Worked example Risk Management in Action

Scenario: Algorithm detects buy signal on AAPL at $150.

Step 1: Determine stop-loss using ATR (Average True Range)

ATR for AAPL = $3(average daily volatility)
Stop-loss = Entry - (2 × ATR) = $150 -$ 6 = $144
Why 2×ATR? Gives "breathing room" for normal volatility without getting stopped out prematurely by noise.

Step 2: Calculate position size

Account: $50{,}000, \text{Risk: } 1\% =$ 500
Risk per share: $150 -$ 144 = $6
Position size: $500 /$ 6 ≈ 83 shares Step 3: Set take-profit
Target = Entry + (3 × ATR) = $150 +$ 9 = $159
Why 3×ATR? Risk-reward ratio of 3:2 (risk $6 to make$ 9)

The trade: Buy 83 shares at $150, stop at$ 144, target $159. Max loss:$ 498 (1% of account).

3. Execution (The "How to Trade" Decision)

What: The method of actually placing orders to minimize costs and market impact.

Why it matters: Poor execution erodes profits. A spread of $0.10 on a$ 50 stock is 0.2% slippage—do this 50 times and you've lost 10% to execution costs alone.

Types of execution algorithms:

TWAP (Time-Weighted Average Price):
- Split large order into equal chunks spread evenly over time
- Use case: When you don't want to signal urgency and can tolerate time risk
VWAP (Volume-Weighted Average Price):
- Split order proportional to expected volume throughout the day
- More aggressive when volume is high (liquid), passive when low
- Use case: Benchmark against average execution price of the day
Implementation Shortfall (Arrival Price):
- Execute agressively at start, then slow down
- Minimize opportunity cost of not being in position
- Use case: When you have strong signal and want immediate exposure

Formula VWAP Calculation

$VWAP = \frac{\sum_{i=1}^{n} (P_i \times V_i)}{\sum_{i=1}^{n} V_i}$ Where:

$P_i$ = price of trade $i$
$V_i$ = volume of trade $i$
$n$ = number of trades in period

Derivation from first principles:

Question: What's the "fair" average price if some trades had more volume?
Intuition: Large volume trades should weigh more heavily (they moved more money)
Method: Weight each price by its volume, then divide by total volume
This is a weighted average where weights = volumes

Why not simple average? A trade of1000 shares at $50 and 100 shares at$ 51 has average price $50.50, but you actually paid closer to$ 50. VWAP correctly gives $50.09.

The Algo Trading Lifecycle

1. Research → 2. Backtest → 3. Paper Trade → 4. Live Trade (small) → 5. Scale 6. Monitor
     ↑                                                                              ↓
     └────────────────────── Feedback Loop ──────────────────────┘

1. Research (Hypothesis Formation):

Observe market pattern or inefficiency
Formulate testable hypothesis: "If X happens, Y follows with Z% probability"

2. Backtest (Historical Validation):

Run algorithm on historical data
Check: Does it actually work? What's the win rate, Sharpe ratio, max drawdown?
Critical: Avoid look-ahead bias (using future info) and survivorship bias (ignoring delisted stocks)

3. Paper Trade (Real-time Simulation):

Run algorithm with live data but fake money
Tests: Does it handle live market conditions? Are fills realistic?

4. Small Live Trade:

Deploy with minimal capital
Verify execution, slippage, and latency match expectations

5. Scale Up:

Gradually increase position sizes
Monitor for capacity constraints (your orders start moving the market)

6. Continuous Monitoring:

Track performance metrics daily
Watch for regime changes (algorithm stops working)

Common mistake Common Mistake: Overfitting in Backtests

The mistake: Your backtest shows 80% win rate and 3.0 Sharpe ratio. You go live and immediately start losing money.

Why it feels right: "The backtest proves it works! The data doesn't lie."

What actually happened: You curve-fitted to historical data. Your algorithm has15 parameters perfectly tuned to past noise, not signal. It's like memorizing test answers instead of learning the subject—fails on new questions.

Example:

You test 1000 variations of moving average periods (5-day with 23-day, 7-day with 31-day, etc.)
You find that 13-day with 47-day MA works best historically (pure chance)
This specific combination never repeats in future because it was noise The fix:

Out-of-sample testing: Split data into training (backtest here) and validation (test here). Algorithm never sees validation data during development.
Walk-forward analysis: Roll forward through time, re-optimize periodically, test on next unseen period.
Simplicity: Fewer parameters = less overfitting risk. A2-parameter system is more robust than 20-parameter.
Economic rationale: Can you explain why the edge exists without looking at data? If not, it's probably spurious.

Steel-man the mistake: Optimizing parameters seems smart—you want the best settings. The problem is distinguishing "best fit to meaningful pattern" from "best fit to random noise." Without out-of-sample validation, you can't tell the difference.

Common mistake Common Mistake: Ignoring Transaction Costs

The mistake: Strategy shows $50,000 profit in backtest, but live trading loses money.

Why it feels right: "My signal is profitable, that's what matters."

What went wrong: You traded200 times per day. Each trade costs:

Commission: $1 per trade × 200 =$ 200/day
Spread: $0.05 per share × 100 shares × 200 =$ 1,000/day
Slippage: $0.02 per share × 100 shares × 200 =$ 400/day
Total: $1,600/day in costs =$ 32,000/month

Your $50,000 backtest profit assumed zero costs. Reality: -$ 32,000/month.

The fix: Include realistic costs in backtest. Model:

Entry_price = Bid_price - Slippage
Exit_price = Ask_price + Slippage
Cost_per_trade = Commission + (Spread × Shares)

Rule of thumb: If profit per trade < 3× transaction costs, strategy isn't viable.

Key Performance Metrics

Formula Sharpe Ratio

$Sharpe = \frac{\overline{R_p} - R_f}{\sigma_p}$

Where:

$\overline{R_p}$ = average portfolio return
$R_f$ = risk-free rate (e.g., T-bill yield)
$\sigma_p$ = standard deviation of portfolio returns

What it means: Return per unit of risk. A Sharpe of 2.0 means you earned 2% excess return for every 1% of volatility.

Why this formula?

You want to measure excess return (above risk-free), not total return
You want to penalize volatility—a smooth10% is better than a choppy 10%
Division by σ normalizes: a 20% return with 10% volatility (Sharpe=2) beats 30% return with 20% volatility (Sharpe=1.5) Interpretation:

Sharpe < 1.0: Poor (barely beating risk-free after adjusting for risk)
Sharpe 1.0-2.0: Good
Sharpe > 2.0: Excellent (rare in practice, often sign of overfitting if in backtest)

Types of Algorithmic Trading Strategies

Trend Following:
- Assumption: Prices exhibit momentum—what goes up continues up
- Signal: Moving average crossover, breakout from range
- Works best in: Trending markets (post-breakout news, commodity cycles)
Mean Reversion:
- Assumption: Prices oscillate around a mean—extreme moves reverse
- Signal: Price deviates >2 standard deviations from moving average
- Works best in: Range-bound, chopy markets (low volatility regimes)
Statistical Arbitrage:
- Assumption: Related assets should move together—deviations are temporary
- Signal: Cointegrated pairs diverge (e.g., Coke vs. Pepsi)
- Example: If Coke/Pepsi spread widens, short Coke, long Pepsi, profit when spread narrows
Market Making:
- Assumption: You profit from bid-ask spread by providing liquidity
- Method: Place limit orders on both sides, earn spread when both fill
- Risk: Inventory risk (you end up long/short when market moves against you)
High-Frequency Trading (HFT):
- Assumption: Speed advantage lets you capture tiny inefficiencies
- Method: Co-locate servers next to exchange, optimize to microsecond latency
- Not accessible to retail traders (requires millions in infrastructure)

Worked example Mean Reversion Strategy: Bollinger Band Bounce

Hypothesis: When price touches lower Bollinger Band, it's oversold and will bounce.

Setup:

Middle Band =20-day SMA
Upper Band = Middle + (2 × 20-day Std Dev)
Lower Band = Middle - (2 × 20-day Std Dev) Signal Logic:

IF Price touches Lower Band:
   AND RSI < 30 (confirming oversold)
   AND Volume > Average Volume (confirming interest)
THEN Buy
Exit:
   IF Price reaches Middle Band (take profit)
   OR Price breaks below Lower Band by >1% (stop loss—trend might be starting)

Why each condition?

Lower Band touch: Price is2 std devs below mean (statistically extreme)
RSI < 30: Confirms momentum is exhausted (oversold)
Volume > avg: Ensures it's not a low-liquidity outlier (reduces slippage)
Exit at Middle: Return to mean achieved (50% retracement)
Stop below Lower: If support breaks, mean reversion failed—cut loss

Expected performance: Small winners (mean reversion distance), occasional large losers (when trend begins). Win rate 60-70%, Risk:Reward ~1:1.

Recall Explain to a 12-Year-Old

Imagine you're playing a video game where you have to catch falling coins. At first, you play manually—you move the basket with your hands. You're pretty good, but you get tired, you blink and miss coins, and you can only watch one part of the screen.

Now imagine you write a set of rules: "If a coin appears in the top-left, move basket there. If two coins fall at once, catch the bigger one first. If a red coin appears, ignore it—it's fake."

You program the computer to follow these exact rules. Now the computer plays for you, never gets tired, never blinks, and can watch the entire screen at once. It catches way more coins than you could manually.

That's algorithmic trading. You figure out the rules for when to buy and sell stocks (the "game"), write them as code, and let the computer execute them automatically. It's faster, more consistent, and can watch thousands of stocks while you sleep. Your job is to write good rules (rules that actually catch coins, not just random movements).

Connections

6.1.02-Learn-basic-backtesting – How to validate your algorithm before risking real money
6.1.03-Quantitative-analysis-indicators – The technical indicators used as signals
6.2.01-Risk-management-in-algo-trading – Position sizing and drawdown management
3.3.01-Types-of-market-orders – Understanding order types for execution algorithms
5.2.01-Technical-vs-fundamental-analysis – The signal types that feed algorithms
4.1.02-Market-volatility-measurement – How volatility affects algo performance

#flashcards/stock-market

What is algorithmic trading? :: The use of computer programs to automatically execute trades based on predefined rules, mathematical models, or statistical patterns without human intervention during execution.

What are the three core decisions every trading algorithm must make?

1) Signal Generation (why trade), 2) Risk Management (how much), 3) Execution (how to trade).

What is a moving average crossover signal?

A buy signal generated when a short-term MA crosses above a long-term MA (bullish), or a sell signal when it crosses below (bearish). E.g., 50-day crossing 200-day.

How do you calculate position size in algorithmic trading?

Position Size = (Risk Capital per Trade) / (Risk per Share), where Risk per Share = Entry Price - Stop Loss Price. This ensures you lose a predetermined % if stopped out.

What is VWAP and why use it?

Volume-Weighted Average Price: sum of (Price × Volume) divided by total volume. Used as execution benchmark to ensure you're not paying more than the average trader that day.

What is overfitting in backtesting?

When your algorithm is tuned to fit historical noise rather than real patterns. It performs well in backtest but fails in live trading because it memorized past data instead of learning generalizable rules.

What is the Sharpe ratio?

(Average Return - Risk-Free Rate) / Standard Deviation. It measures return per unit of risk. Higher is better; >2.0 is excellent.

What is maximum drawdown (MDD)?

The largest peak-to-trough decline in account value during a period. Shows worst-case loss you'd have to endure before recovery.

What is mean reversion?

Trading strategy based on the assumption that prices oscillate around a mean value. When price deviates far from mean (e.g., >2 standard deviations), it will likely revert back.

What is the purpose of out-of-sample testing?

To validate that your algorithm works on data it has never seen during development, preventing overfitting to historical patterns.

Why must transaction costs be included in backtests?

Because commissions, spreads, and slipage can erase profits from high-frequency strategies. A backtest showing profit might actually lose money after real costs.

What does ATR stand for and how is it used?

Average True Range: measures volatility. Used to set stop-losses (e.g., Entry -2×ATR) that account for normal price fluctuation without premature exit.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Algorithmic trading matlab hai ki ap computer ko exact rules de do kiab buy karo aur kab sell karo, fir computer automatically execute kar deta hai. Yeh manual trading se kafi better hai kyunki computer emotional nahi hota, milliseconds mein decision leta hai, aur ek sath hazaron stocks ko track kar sakta hai.

Teen main chezein hoti hain har algo mein: pehla, signal generation (yeh decide karta hai ki trade kyun karna hai—jaise moving average cross ho gayi ya price oversold hai). Dosra, risk management (yeh bata hai kitne shares kharidne hain taki agar loss ho toh sirf 1-2% account ka jaye). Tesra, execution (yeh decide karta hai ki order kaise place karna hai taki slippage aur cost kam rahe—VWAP ya TWAP algorithms use karte hain).

Sabse badi galti jo naye traders karte hain woh hai overfitting: matlab backtest mein toh algorithm bahut acha lag raha tha, lekin live mein fail ho gaya kyunki woh purane data ke noise ko memorize kar liya tha, asliyat ka pattern nahi seekha. Isliye hamesha out-of-sample testing karo aur transaction costs ko backtest mein include karo, warna profit dikhega lekin reality mein paisa dob jayega.

Algorithmic trading ka matlab yeh nahi ki ap blindly computer par depend kar do—tumhe samajhna padega ki strategy kyun kaam karti hai (economic rationale), performance metrics track karne padenge (Sharpe ratio, max drawdown), aur continuously monitor karna padega ki market regime change toh nahi ho gayi. Automation ka matlab efficiency hai, magic nahi.

Test yourself — Algorithmic & Quant Trading

Connections