How I built an Automated Portfolio Manager using Python and React tags:

Market Insights Center — Mon, 22 Dec 2025 20:31:24 +0000

The Architecture

The system is split into two parts:

Frontend (React): A dashboard where I can configure portfolios, view performance, and trigger runs.
Backend (Python): The brain. It handles data fetching, signal processing, and trade calculation. I chose Python because the ecosystem for financial data is unbeatable (pandas, yfinance, numpy). The backend exposes endpoints that the React app consumes to display the "Nexus" — my term for a collection of strategies.

The Core Logic: Not Just Buy/Sell

The heart of the application is
invest_command.py
. Instead of a binary "Buy" or "Sell" signal, I wanted a gradient — a Confidence Score from 0 to 100. This allows for nuanced position sizing.

I settled on a modified Exponential Moving Average (EMA) Crossover strategy. Specifically, I compare the 8-period EMA (fast trend) against the 55-period EMA (slow trend).

Here is the simplified logic I implemented:

# Fetches historical data and calculates EMAs
data['EMA_8'] = data['Close'].ewm(span=8, adjust=False).mean()
data['EMA_55'] = data['Close'].ewm(span=55, adjust=False).mean()
# The "Invest Score" Calculation
# We look at the percentage difference between the two EMAs
diff_percent = (ema_8 - ema_55) / ema_55
# Scale it: a 25% difference roughly maps to a max score
# The +0.5 centers the score at 50 (neutral)
raw_score = (diff_percent * 4 + 0.5) * 100

If the short-term trend is significantly above the long-term trend, the score approaches 100 (Full Allocation). If it crosses below, it drops towards 0 (Sell/Short).

Dynamic Amplification

One problem with raw EMAs is that they can be sluggish. To counter this, I added an Amplification Factor. This parameter stretches the score away from the center. A score of 60 might be "meh" in a conservative strategy, but with 1.5x amplification, it becomes a strong buy signal.

amplified_score = max(0, (raw_score * amplification) - (amplification - 1) * 50)

This simple math lets me tune the aggressiveness of different portfolios without rewriting the core algorithm.

From Score to Shares: The Tailoring Process

Getting a score of "85" is great, but you can't send "85" to a broker. You need to convert that into a share count. This is where the Tailoring phase comes in.

The system calculates a combined_percent_allocation for every asset based on its relative strength against the total amplified score of the portfolio.

# Pseudo-code for sizing
target_amt = total_portfolio_value * (alloc_pct / 100.0)
shares = target_amt / live_price
if use_fractional_shares:
    final_shares = round(shares, 2)
else:
    final_shares = math.floor(shares)

It handles edge cases gracefully:

Fractional Shares: If the broker supports it, we calculate up to 2 decimal places.
Minimums: It ensures trades obey minimum dollar amounts (e.g., $1.00) to avoid broker rejections.
Cash Sweep: Any "dust" left over from rounding is swept up and used to buy an extra fraction of the cheapest or highest-weighted stock, ensuring maximum capital efficiency.

"Nexus": A Portfolio of Portfolios

The most challenging (and fun) part was building the Nexus system (
nexus_command.py
). I realized one algorithm doesn't fit every market condition. Sometimes I want a "Breakout" strategy, other times a "Dividend Cultivator".

I built a recursive engine that treats other strategies as components. A Nexus portfolio is just a JSON configuration that can contain:

Static Tickers: Classic "Buy AAPL".
Dynamic Lists: "Top 10 SP500 stocks by Market Score".
Sub-Portfolios: A reference to another portfolio configuration. The backend resolves this recursively. If I include a "Tech Sector" sub-portfolio inside my main "Retirement" portfolio, the system calculates the scores for the tech stocks, applies their specific weighting, and rolls the results up to the parent.

Safety Mechanisms

Automated trading is terrifying. To sleep at night, I implemented a "Circuit Breaker" based on a global Market Score.

Before allocating a single dollar, the system checks the overall health of the SP500. If the general market score dips below 50 (indicating a downtrend), the system flips a sell_to_cash_active switch.

if market_score < 50:
    # If a stock is weak (<50), force sell it entirely.
    # Don't hold "mediocre" stocks in a bear market.
    score_for_alloc = 0.0 if raw_score < 50 else raw_score

This ensures that in a crash, the system naturally rotates into cash, preserving capital.

Closing Thoughts

This project taught me that the "algorithm" is often the easiest part. The real challenge is state management — tracking fractional shares, handling API rate limits, and ensuring that a "Buy" order in the database actually matches reality in the brokerage account.

It’s not a money printer, but it is a disciplined, automated execution engine. And for a developer, seeing code successfully navigate a market correction is its own kind of ROI.

DEV Community: Market Insights Center