top of page

Wharton Global High School Investment Challenge

Wharton Global High School Investment Challenge — Financial Engineering and Strategic Asset Management

 

As the team strategist in the Wharton Global High School Investment Challenge, I operated at the intersection of quantitative finance and computer science. Tasked with managing a simulated $100,000 portfolio, I led the design and execution of our team’s investment strategy—leveraging mathematical models, real-time data analysis, and programming tools to drive decisions grounded in both empirical analysis and market dynamics. Our participation required building a dynamic financial thesis that integrated technical indicators, global macroeconomic signals, and algorithmic forecasting.

​​​​

​

Quantitative Modeling and Risk Analysis

​​

To assess option pricing and volatility spreads, I implemented both the Black-Scholes Model and the Heston Stochastic Volatility Model. While Black-Scholes provided closed-form solutions for standard options, the Heston Model allowed us to model volatility as a random process—enhancing our ability to assess risk in unstable market environments.

These models were built and run in Python, using libraries like NumPy, SciPy, and Matplotlib for computational processing and data visualization. I programmed scripts to:

  • Compute Greeks (Delta, Gamma, Vega) to understand sensitivity and hedge accordingly

  • Fit volatility surfaces from historical data using implied volatility skews

  • Compare closed-form vs. Monte Carlo simulations for long-term risk modeling

This phase deepened my understanding of both stochastic calculus and numerical optimization, especially as we iterated on parameter tuning using historical S&P 500 options data.​​

​​

​

Equity Screening and Valuation Engine

​​

Alongside derivatives modeling, I designed a Python-based stock screening engine using fundamental and technical indicators. This tool parsed through real-time financial data using the Yahoo Finance API and filtered stocks based on a composite of:

  • P/E and PEG ratios, EV/EBITDA, and ROE metrics

  • 50/200-day moving averages, Bollinger Bands, and RSI thresholds

  • Industry trends and beta alignment for portfolio diversification

The tool allowed us to quickly backtest strategies, simulate returns under different economic scenarios, and rebalance our holdings based on quarterly performance.​​

​​

​

Portfolio Structuring and Strategic Allocation​

​

As the challenge progressed, I built an allocation matrix integrating the Capital Asset Pricing Model (CAPM) to evaluate the expected return of each asset in our portfolio. This was complemented by scenario analysis based on Federal Reserve decisions, inflation outlooks, and geopolitical developments affecting energy and tech sectors.

My responsibilities included:

  • Creating a rolling Sharpe ratio calculator to optimize risk-adjusted returns

  • Developing position sizing rules based on max drawdown and VaR thresholds

  • Modeling correlations using covariance matrices to identify hedging opportunities

We eventually submitted a 10+ page investment report, articulating our financial rationale, risk-mitigation strategies, and model assumptions—all backed by data visualizations and simulation results.

​​

​​​

Conclusion
​

This project pushed me to blend advanced mathematical modeling with real-time strategy in a volatile environment. From implementing stochastic differential equations and building Python scripts to evaluating global trends and producing a structured investment thesis, my role encompassed both the technical and strategic heart of portfolio management. The challenge solidified my interest in quantitative finance and gave me a real-world lens into the fusion of engineering, economics, and algorithmic design.

Program Samples

Screenshot 2025-07-07 165440.png

1. Black Scholes Option Pricing Graph

 

import numpy as np

import matplotlib.pyplot as plt

from scipy.stats import norm

 

def black_scholes_call(S, K, T, r, sigma):

    d1 = (np.log(S/K) + (r + 0.5 * sigma**2)*T) / (sigma * np.sqrt(T))

    d2 = d1 - sigma * np.sqrt(T)

    return S * norm.cdf(d1) - K * np.exp(-r*T) * norm.cdf(d2)

 

S = np.linspace(50, 150, 100)

K = 100

r = 0.05

sigma = 0.2

 

for T in [0.25, 0.5, 1]:

    call_prices = black_scholes_call(S, K, T, r, sigma)

    plt.plot(S, call_prices, label=f'T = {T} yr')

 

plt.title("Black-Scholes Call Option Prices")

plt.xlabel("Stock Price")

plt.ylabel("Call Option Price")

plt.legend()

plt.grid(True)

plt.show()

 

2. Heston Model- Volatility Surface Plot

 

from mpl_toolkits.mplot3d import Axes3D

from matplotlib import cm

from matplotlib.ticker import LinearLocator

import matplotlib.pyplot as plt

import numpy as np

 

K = np.linspace(80, 120, 30)  # Strike prices

T = np.linspace(0.1, 2, 30)   # Maturities

K, T = np.meshgrid(K, T)

 

# Simulated Heston-style surface (placeholder)

sigma_0 = 0.2

vol_surface = sigma_0 + 0.1 * np.sin(K/10) * np.exp(-T)

 

fig = plt.figure()

ax = fig.add_subplot(111, projection='3d')

surf = ax.plot_surface(K, T, vol_surface, cmap=cm.viridis, linewidth=0, antialiased=False)

 

ax.set_title('Simulated Volatility Surface (Heston Model)')

ax.set_xlabel('Strike Price')

ax.set_ylabel('Time to Maturity')

ax.set_zlabel('Implied Volatility')

plt.show()

 

3. Portfolio Allocation Pie Chart

import matplotlib.pyplot as plt

 

labels = ['Technology', 'Healthcare', 'Energy', 'Financials', 'Consumer Goods']

sizes = [30, 20, 15, 20, 15]

colors = ['#4CAF50', '#2196F3', '#FFC107', '#FF5722', '#9C27B0']

 

plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=140)

plt.axis('equal')

plt.title('Final Portfolio Allocation by Sector')

plt.show()

 

4. Sharpe Ratio Over Time

 

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

 

# Simulated daily returns

np.random.seed(42)

returns = np.random.normal(0.001, 0.02, 252)

risk_free_rate = 0.0001

rolling_window = 20

 

excess_returns = returns - risk_free_rate

rolling_sharpe = pd.Series(excess_returns).rolling(rolling_window).mean() / pd.Series(excess_returns).rolling(rolling_window).std()

 

plt.plot(rolling_sharpe)

plt.title('Rolling Sharpe Ratio (20-day window)')

plt.xlabel('Day')

plt.ylabel('Sharpe Ratio')

plt.grid(True)

plt.show()

 

5. Correlation Heat Map of Portfolio Assets

 

import seaborn as sns

import pandas as pd

import numpy as np

 

# Simulate returns for 5 stocks

np.random.seed(1)

data = np.random.normal(0, 1, (100, 5))

df = pd.DataFrame(data, columns=['AAPL', 'JNJ', 'XOM', 'JPM', 'TSLA'])

 

corr = df.corr()

 

sns.heatmap(corr, annot=True, cmap='coolwarm', vmin=-1, vmax=1)

plt.title('Asset Correlation Heatmap')

plt.show()

bottom of page