Most explanations of the greeks stop at the definitions. That is enough to pass a quiz and not enough to write a risk check. A systematic options book needs the greeks as live numbers, aggregated across every open leg, compared against a limit, and acted on without a human in the loop. This piece is about that version of them.
What the four greeks actually measure
Layered model
What each greek is a sensitivity to
Delta and vega describe present exposure. Gamma describes how quickly the delta figure stops being true. Theta is the only one that moves without the market moving.
Delta is a first-order sensitivity to underlying price, measured in option points per point of underlying. Gamma is second order, the change in delta per point of underlying movement. Theta is the change in option value per day of elapsed time. Vega is the change in option value per one point change in implied volatility. Delta and vega state current exposure while gamma states how fast the delta estimate decays.
Managing a book on delta alone means managing a number with an expiry date. Gamma is what sets that date, which is why the two must be limited separately.
Each greek is a partial derivative of the option price with respect to one input, holding the others fixed. That "holding the others fixed" clause is the part that causes trouble in practice, because in a real market none of the inputs stay fixed.
Greek
Sensitivity to
Units
What it tells your code
Delta
Underlying price
Option points per 1 point of underlying
Net directional exposure to hedge or cap
Gamma
Delta itself
Delta change per 1 point of underlying
How quickly the hedge goes stale
Theta
Time
Option points per day
Expected carry if nothing moves
Vega
Implied volatility
Option points per 1 IV point
Exposure to a repricing of volatility
The four greeks that matter for a retail systematic book
Delta and vega are first-order: they tell you what you are exposed to now. Gamma is second-order: it tells you how wrong the first-order number will be after the market moves. A book managed only on delta is managed on a number with a known expiry date, and gamma is what sets that date.
Delta and gamma across the strike chain
Comparison chart
Delta rises monotonically, gamma peaks at the money
Both series are indexed to their own peak so the shapes can be compared on one axis. The absolute magnitudes are not comparable and are not the point.
Indexed to each series peak. Call delta rises steadily across the chain, from about 5 at four percent out of the money through 50 at the money to about 92 deep in the money. Gamma instead peaks at the money at 100 and falls away on both sides, to about 12 at four percent out of the money and 30 deep in the money. Delta is monotonic across strikes while gamma is single-peaked.
The gamma peak sitting exactly at the money is the structural reason expiry-day at-the-money positions behave unlike anything else in the chain.
Delta moves monotonically across the chain: deep out-of-the-money options have almost none, at-the-money options sit near 0.5, and deep in-the-money options approach 1. Gamma does not behave that way. Gamma peaks at the money and falls away on both sides.
This is the structural fact behind most expiry-day surprises. An at-the-money option a day from expiry has enormous gamma, which means its delta swings between near-zero and near-one over a small move in the underlying. A position that was delta-neutral when you checked it can be materially directional a few points later.
Theta is not free money
Trend chart
Time value does not decay in a straight line
An at-the-money option loses time value roughly in proportion to the square root of remaining time, so the daily loss accelerates into expiry.
At-the-money time value indexed to 100 five days before expiry. The actual curve falls to 89, 78, 63, 45 and finally 14 in the closing hours, staying above a straight-line assumption throughout. The daily loss grows from about 11 index points in the first day to roughly 31 in the last, so the final sessions carry the majority of the decay.
The accelerating decay and rising gamma are the same phenomenon viewed differently. Concentrating theta collection into the last days concentrates gamma risk by the same act.
Short-premium strategies are usually described as "collecting theta". The description is accurate and the framing is misleading. Theta is not a yield paid for patience; it is the compensation for being short gamma and short vega. The market pays you to hold a position that loses money when the underlying moves and when volatility rises.
Theta also does not accrue linearly. For an at-the-money option, time value decays slowly at first and then very quickly in the final days. That is the same phenomenon as rising gamma seen from a different angle: the two are inseparable, and any strategy that concentrates theta collection into the last days of an expiry is concentrating gamma risk by the same act.
Vega and the expiry-week volatility crush
Vega scales with time to expiry. A monthly option has meaningful vega; a weekly option in its final two days has very little. The practical consequence is that the same nominal position is a volatility trade early in its life and a gamma trade at the end of it, without you changing anything.
Indian weekly expiries make this cycle fast and repetitive. Implied volatility in the front expiry typically firms up ahead of an event and drains afterwards, and a position sized on early-week vega assumptions can be carrying an entirely different risk profile by the final session. Expiry-day options mechanics covers the settlement side of the same week.
Vega
Dominates early
Longer-dated legs, IV repricing risk
Gamma
Dominates late
Final sessions, ATM strikes
Both
Must be limited separately
One cap cannot govern the other
Which greek dominates your position
Decision tree
The sign of your gamma decides what to watch
Almost every retail structure is dominated by one exposure. Identifying which one tells you where the limit needs to be tight.
Start from whether the position is net long or net short options. Net long means long gamma and long vega while paying theta, so the dominant risk is decay while waiting for a move. Net short means short gamma and short vega while earning theta, so the dominant risk is gamma near expiry and the response is to cap size and shorten the hedging loop.
A single delta cap constrains neither branch. Long positions need a decay budget; short positions need a gamma limit that tightens as expiry approaches.
Before writing limits, work out which exposure your strategy is actually taking. Most retail structures are dominated by one greek, and the risk check should be sized around that one rather than spread evenly across all four.
Structure
Dominant greek
The risk that actually bites
Directional long option
Delta, then theta
Being right slowly — the move arrives after decay has eaten the premium
Short straddle / strangle
Gamma, then vega
A gap through the short strike; delta hedges arrive too late
Calendar spread
Vega
Term structure moving against you while the underlying does nothing
Vertical spread
Delta
Bounded and well behaved — the reason it suits slower loops
Expiry-day ATM anything
Gamma
Delta becoming unrecognisable between two loop iterations
Dominant exposure by structure
Wiring greeks into an automated risk check
The useful form of a greek limit is a signed aggregate per underlying, evaluated before every order and on a timer, with a defined action when it is breached. Anything softer than that is a dashboard, not a control.
risk/greek_limits.pypython
from dataclasses import dataclassNIFTY_LOT = 75 # confirm against the current contract specification@dataclass(frozen=True)class GreekLimits: max_abs_delta: float # in underlying units max_abs_gamma: float # delta change per point max_abs_vega: float # rupees per IV point min_theta: float # allow negative carry only to this depthdef net_greeks(legs): """Signed aggregation. quantity is negative for short legs.""" net = {"delta": 0.0, "gamma": 0.0, "vega": 0.0, "theta": 0.0} for leg in legs: size = leg.quantity * leg.lot_size for greek in net: net[greek] += getattr(leg, greek) * size return netdef breaches(legs, limits: GreekLimits) -> list[str]: net = net_greeks(legs) found = [] if abs(net["delta"]) > limits.max_abs_delta: found.append(f"delta {net['delta']:.0f} over {limits.max_abs_delta:.0f}") if abs(net["gamma"]) > limits.max_abs_gamma: found.append(f"gamma {net['gamma']:.2f} over {limits.max_abs_gamma:.2f}") if abs(net["vega"]) > limits.max_abs_vega: found.append(f"vega {net['vega']:.0f} over {limits.max_abs_vega:.0f}") if net["theta"] < limits.min_theta: found.append(f"theta {net['theta']:.0f} below {limits.min_theta:.0f}") return founddef may_send(order, legs, limits) -> tuple[bool, str]: projected = legs + [order.as_leg()] found = breaches(projected, limits) if found: return False, "; ".join(found) return True, "within limits"
Aggregate signed greeks per underlying and gate new orders on them. The gate returns a reason so rejections are explainable after the fact.
Two details in that sketch matter more than the arithmetic. The check runs on the projected position including the order being considered, not the current one, so a limit cannot be crossed by the very order that breaches it. And it returns a reason string, which is what lets you answer why an order was rejected three weeks later.
Before a greek limit counts as implemented
Greeks are aggregated per underlying with correct signs
Short legs negative. Assert this in a test with a hand-computed two-leg example.
Limits are checked on the projected position, not the current one
Pre-trade, on the position the order would create.
A timer re-checks limits even when no orders are being sent
Gamma moves your delta without any action from you. A purely pre-trade check misses that entirely.
Gamma has its own limit, tightened for the final sessions of an expiry
A single delta cap does not constrain gamma, and expiry-week gamma is where the cap needs to be tightest.
The breach action is defined and tested, not left to be decided later
Reduce, hedge or flatten. Whichever it is, it should have been exercised in a rehearsal.
Greek inputs have a staleness check
A greek computed from a quote that stopped updating is worse than no greek, because it reads as reassuring.
None of this makes an options strategy profitable. It makes the risk you are taking legible to the system that is taking it, which is the prerequisite for finding out whether the strategy has an edge at all. Position sizing for algo portfolios covers the next question, which is how large any of this should be.
Frequently asked questions
What do delta, gamma, theta and vega measure?
Delta is the change in option price per one point move in the underlying, so it represents directional exposure. Gamma is the change in delta per one point move, so it measures how fast that directional exposure shifts. Theta is the change in option price per day of elapsed time. Vega is the change in option price per one point change in implied volatility.
Why is gamma the most dangerous greek for automated strategies?
Because it invalidates your delta between checks. If a loop re-hedges every sixty seconds, the delta it acted on is only accurate for sixty seconds, and high gamma shortens the window over which that assumption holds. A position that was delta-neutral at the last check can be materially directional a few points later, which is why expiry-week at-the-money positions need either a faster loop or less gamma.
Is collecting theta on short options really low risk?
No. Theta is the compensation for being short gamma and short vega, not a yield paid for patience. A short straddle earns at most the premium collected and can lose an amount limited only by how far the underlying travels, so weeks of small theta gains can be erased by a single gap. The payoff shape is asymmetric by construction.
Why does vega matter less close to expiry?
Vega scales with time to expiry, so a weekly option in its final sessions has very little of it while a monthly option has meaningful vega. The practical consequence is that an unchanged position transitions from being a volatility trade early in its life to a gamma trade at the end of it, without the trader doing anything.
Should I use broker-supplied greeks or compute my own?
Either, but not both in the same aggregate. Broker greeks and your own Black-Scholes output will differ because they use different implied volatility and interest-rate assumptions. Choose one source, apply it consistently across every leg of a position, and record in the audit log which source produced each number.
How often should an automated system re-check greek limits?
Before every order on the projected position, and additionally on a timer regardless of order activity. The pre-trade check alone is insufficient because gamma changes your delta with no action from you, so a position can breach a limit while the system is idle.