← Morgan Stanley Interview Insights
Start by identifying whether the option is at-the-money (ATM), in-the-money (ITM), or out-of-the-money (OTM) using the spot vs strike. Then use rule-of-thumb approximations for delta, gamma, and vega based on moneyness and time to expiry, and adjust for volatility and rate if needed.
Pro tip: Mention that these approximations assume no dividends and are most accurate for ATM options; for ITM/OTM, delta approaches 1 or 0, and gamma/vega are smaller. Also, note that vega is highest for ATM options and decreases as you move away from the money.
Compare spot to strike to determine if the option is ATM, ITM, or OTM. This sets the baseline for delta and the magnitude of gamma and vega.
For ATM, delta is approximately 0.5 (call) or -0.5 (put). For ITM, delta approaches 1 (call) or -1 (put); for OTM, it approaches 0. Adjust slightly based on time to expiry and volatility.
Gamma is highest for ATM options and decreases as you move ITM or OTM. For ATM, gamma is roughly 0.4 / (spot * vol * sqrt(time)). For ITM/OTM, gamma is smaller.
Vega is also highest for ATM options. For ATM, vega is approximately 0.4 * spot * sqrt(time). For ITM/OTM, vega is lower. Volatility scales vega proportionally.
Higher volatility increases the time value, making OTM options more valuable and increasing gamma and vega for near-the-money options. Interest rates have a minor effect on delta and gamma for short-dated options, but can affect vega slightly.
AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.
Start by acknowledging that exact Gaussian CDF/PDF are not available in closed form, so approximations are necessary. Then present a practical, accurate method like the Abramowitz-Stegun rational approximation or the Zelen & Severo algorithm, and discuss trade-offs between accuracy and speed. Conclude with implementation considerations for a production environment like Morgan Stanley.
Pro tip: Mention that you would validate the approximation against known values (e.g., at 0, 1.96) and consider using a lookup table with interpolation for extreme speed, but be ready to explain the accuracy trade-off.
Ask about the required accuracy, performance constraints, and whether the approximation will be used in a latency-sensitive trading system or for offline analysis.
Select a well-known method such as the Abramowitz-Stegun formula for the CDF or the Box-Muller transform for generating normal variates, and explain why it fits the requirements.
Describe how to implement the chosen method efficiently in code, using techniques like Horner's method for polynomial evaluation and avoiding expensive operations like exponentiation where possible.
Explain how you would test the approximation against known values or high-precision libraries, and discuss error bounds and edge cases (e.g., tails).
Summarize the trade-offs between accuracy, speed, and memory usage, and justify your final choice for the given context.
AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.
Start by defining the Black-Scholes Greeks (Delta, Gamma, Vega, Theta, Rho) and their mathematical dependencies on the inputs (S, K, T, σ, r). Then explain how each Greek changes with respect to each input, focusing on monotonicity and convexity. Finally, describe how to use this knowledge to sanity-check numerical estimates by perturbing inputs and verifying that the Greeks behave as expected.
Pro tip: Emphasize that sanity-checking Greeks via perturbation is a practical way to catch bugs in pricing libraries, and mention that in production systems, you often use finite differences to validate analytic Greeks, especially for exotic options where closed-form solutions may not exist.
List the five main Greeks (Delta, Gamma, Vega, Theta, Rho) and the Black-Scholes inputs: spot price S, strike K, time to maturity T, volatility σ, and risk-free rate r. Clarify that Greeks are partial derivatives of the option price with respect to these inputs.
For each Greek, describe how it scales with each input. For example, Delta increases with S for calls (from 0 to 1), Gamma peaks near ATM and decreases with T, Vega increases with T and is highest ATM, Theta is negative and its magnitude increases as T decreases, Rho increases with T for calls.
Explain that you can perturb one input at a time (e.g., bump S by a small amount) and recompute the option price to approximate the Greek via finite differences. Then compare the numerical result to the analytic Greek to ensure consistency.
Discuss how this is implemented in code: unit tests that verify Greeks against finite differences, handling edge cases (e.g., T→0, deep ITM/OTM), and ensuring numerical stability. Mention that automated checks can catch regressions in pricing models.
AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.