Build a 90/10 Portfolio Simulator with Python

Two Engines, One Portfolio: The 90/10 Strategy Meets Python

What if you could stress-test your entire investment philosophy before putting real money on the line? That is exactly what Part 4 of the 'Building Investment Systems with Python' series sets out to do — constructing a live, interactive simulator that models a 90/10 portfolio split between dividend-compounding core holdings and deep-value growth satellites.

The approach reflects a growing trend among retail and institutional investors alike: using AI-assisted tooling and Python-based quantitative frameworks to replace gut-feel allocation with data-driven strategy.

The Philosophy Behind 90/10

The 90/10 portfolio concept is straightforward but powerful. Ninety percent of capital goes into dividend-growing positions — companies with a track record of increasing payouts year over year. The remaining 10% targets deep-value satellite picks with asymmetric upside, typically aiming for 3x to 5x returns.

This barbell structure balances income reliability against concentrated growth bets. The dividend core acts as a 'snowball,' compounding reinvested dividends over time, while the satellite sleeve provides optionality without jeopardizing the portfolio's foundation.

The concept draws on principles familiar to followers of value investing, but the implementation layer is thoroughly modern — built entirely in Python with live data feeds and interactive visualization.

Building the Dividend Snowball Model

The core engine of the simulator models dividend reinvestment over multi-year horizons. Key inputs include initial position size, current dividend yield, expected annual dividend growth rate, and reinvestment frequency.

Using libraries like NumPy and Pandas, the model projects how reinvested dividends accelerate compounding. For example, a $10,000 position in a stock yielding 3.5% with 8% annual dividend growth can generate meaningful passive income within a decade — but the simulator lets users visualize exactly how that trajectory shifts with different assumptions.

The snowball effect becomes particularly dramatic when users adjust the dividend growth rate slider. A seemingly small difference — say, 6% versus 10% annual dividend growth — compounds into a massive divergence over 15 to 20 years. This kind of sensitivity analysis is precisely why building the tool in Python is so valuable.

The Growth Satellite Simulator

The satellite component takes a different approach. Here, the simulator models concentrated deep-value bets with defined entry points, target multiples, and time horizons. Users can input a conviction-weighted position, set a target return (e.g., 3x or 5x), and run Monte Carlo simulations to estimate probability-weighted outcomes.

Python's ecosystem shines in this context. Libraries like Matplotlib and Plotly enable interactive charts, while SciPy handles probability distributions for scenario modeling. The simulator can pull live market data via APIs such as yfinance, grounding hypothetical models in real-world pricing.

The satellite simulator also incorporates position-sizing logic. Since the satellite sleeve is capped at 10% of total portfolio value, the tool enforces discipline — preventing users from over-allocating to speculative positions regardless of conviction level.

Why Python-Based Investment Tools Are Gaining Traction

The rise of open-source quantitative finance tools has democratized capabilities that were once exclusive to hedge funds. Platforms like QuantConnect, Zipline, and custom Python stacks now give individual investors institutional-grade modeling power.

According to a 2024 survey by JetBrains, Python remains the most popular language for data science and financial modeling, with over 70% of quant-finance practitioners citing it as their primary tool. The integration of AI — particularly large language models for code generation — has further lowered the barrier to entry for building custom investment simulators.

This tutorial series exemplifies that shift. Rather than relying on off-the-shelf robo-advisors, builders are constructing bespoke systems tailored to their own investment philosophies.

Key Takeaways for Builders

The 90/10 simulator offers several practical lessons. First, separating portfolio components into distinct engines — each with its own logic and risk parameters — creates cleaner, more maintainable code. Second, interactive visualization transforms static backtests into dynamic decision-support tools. Third, enforcing allocation constraints programmatically removes emotional bias from position sizing.

For developers looking to replicate this approach, the core stack includes Python 3.10+, Pandas, NumPy, Plotly for interactive charts, and yfinance for market data. The full tutorial includes code walkthroughs for both the dividend snowball model and the satellite simulator.

What Comes Next

Parts 5 and 6 of the series promise to layer in portfolio rebalancing logic and risk management overlays. As AI-powered coding assistants like GitHub Copilot and Claude make it faster than ever to prototype financial tools, the gap between 'idea' and 'working simulator' continues to shrink.

For investors who think in systems rather than stock tips, Python remains the ultimate power tool — and the 90/10 framework provides a compelling blueprint for putting it to work.