You can build an interactive technical analysis dashboard in about 100 lines of Python. No backend. No SQL. No React. Streamlit and yfinance handle everything—data fetching, calculation, visualization—and let you change tickers and timeframes in real time. The gap between "I want to see RSI on AAPL" and "I'm looking at a chart" compresses to minutes.
Key Takeaways
- Streamlit converts Python scripts into web apps without HTML/CSS—you write functions, Streamlit renders the interface
- yfinance fetches live market data from Yahoo Finance and calculates technical indicators using pandas operations
- This approach works for personal research dashboards—production trading systems require paid data feeds and different architecture
Before You Start
This guide assumes you know what RSI, MACD, and moving averages measure and why traders watch them. You should be comfortable running Python scripts from the command line and have worked with pandas DataFrames before.
The dashboard fetches data from Yahoo Finance through yfinance—free delayed quotes suitable for research and education, not for production trading algorithms. If you need real-time institutional-grade data, this approach has hard limits covered in the final section.
What You Need
- Python 3.8 or newer installed on your system
- pip package manager (included with Python)
- A terminal or command prompt with permission to install packages
- A text editor or IDE—VS Code, PyCharm, or even Notepad++ works
- Internet connection—yfinance fetches data from Yahoo Finance servers
- No API keys required—yfinance does not require authentication for basic usage
Step 1: Install Streamlit and yfinance
Open your terminal and create a new project directory. Run pip install streamlit yfinance pandas plotly to install the core dependencies.
What each library does:
- Streamlit: web framework
- yfinance: market data
- pandas: time series manipulation
- plotly: interactive charts
Verify installation by running streamlit hello. You should see a demo app open in your browser at localhost:8501. If the demo loads, Streamlit is working and can serve local web apps.
Step 2: Fetch Stock Data with yfinance
Create a new file called dashboard.py. Import yfinance and fetch historical data using yf.download(ticker, start=start_date, end=end_date). The function returns a pandas DataFrame with columns for Open, High, Low, Close, Volume, and Adjusted Close.
For technical indicators, you will use the Close column.
Add Streamlit's text input widget with st.text_input("Enter Ticker", value="AAPL") so users can change the stock symbol. This creates an interactive field that reloads the data when the ticker changes—no submit button needed.
Step 3: Calculate RSI Using Pandas
The Relative Strength Index measures momentum on a scale from 0 to 100. Calculate the 14-day RSI by finding price changes, separating gains and losses, computing their exponential moving averages, then applying the formula RSI = 100 - (100 / (1 + RS)) where RS is the average gain divided by average loss.
In pandas:
delta = df['Close'].diff()gain = delta.where(delta > 0, 0).ewm(span=14).mean()loss = -delta.where(delta < 0, 0).ewm(span=14).mean()rs = gain / loss
This vectorized approach processes the entire time series at once. No loops.
Step 4: Calculate MACD and Signal Line
MACD (Moving Average Convergence Divergence) measures trend momentum using two exponential moving averages. Calculate the 12-day EMA with df['Close'].ewm(span=12).mean() and the 26-day EMA the same way. MACD is the difference: macd = ema12 - ema26.
The signal line is a 9-day EMA of MACD itself: signal = macd.ewm(span=9).mean(). The histogram (MACD minus signal) shows divergence strength.
Traders watch for crossovers. When MACD crosses above the signal line, it suggests bullish momentum. These calculations happen in pandas with no external libraries.
Step 5: Add Simple and Exponential Moving Averages
Calculate the 50-day simple moving average with df['Close'].rolling(window=50).mean() and the 200-day SMA the same way. For exponential moving averages, use .ewm(span=50).mean() instead of .rolling().
Store these as new DataFrame columns so you can plot them alongside price.
The 50-day and 200-day moving averages are standard trend indicators—the "golden cross" (50-day crossing above 200-day) signals potential uptrend to many traders. Add a Streamlit selectbox with st.selectbox("Moving Average Type", ["SMA", "EMA"]) to let users toggle between calculation methods.
Step 6: Visualize Indicators with Plotly
Use Plotly's graph_objects module to create interactive charts. Build a subplot layout with plotly.subplots.make_subplots(rows=3, cols=1)—one row for price and moving averages, one for RSI, one for MACD.
Add traces with fig.add_trace(go.Scatter(x=df.index, y=df['Close'], name='Close Price'), row=1, col=1). Repeat for each indicator.
Set RSI horizontal lines at 30 (oversold) and 70 (overbought) using fig.add_hline(y=30, line_dash="dash", row=2, col=1). Display the chart in Streamlit with st.plotly_chart(fig, use_container_width=True).
The interactive chart lets users zoom, pan, and hover over data points to see exact values. No static images.
Step 7: Add Date Range Controls
Include Streamlit's date input widgets to let users customize the timeframe: start_date = st.date_input("Start Date", value=pd.to_datetime("2023-01-01")). Pass these dates to yf.download() to fetch only the requested period.
Add validation to ensure the start date comes before the end date—use if start_date >= end_date: st.error("Start date must be before end date") to display an error message. This prevents empty DataFrames and confusing chart outputs.
The date picker shows a calendar interface and returns a Python datetime object.
Step 8: Run and Test the Dashboard Locally
Save your dashboard.py file and run streamlit run dashboard.py from the terminal. Streamlit starts a local web server and opens your browser to localhost:8501.
Change the ticker from AAPL to MSFT. The entire dashboard should reload with Microsoft's data and recalculated indicators.
Check that RSI values stay between 0 and 100, MACD shows both positive and negative values, and moving averages smooth price fluctuations. If charts appear empty, verify your date range includes enough data—indicators like the 200-day SMA need at least 200 trading days to calculate.
Common Problems and Fixes
yfinance returns empty DataFrame—This happens when the ticker symbol is invalid or Yahoo Finance has no data for the requested period. Add error handling: if df.empty: st.warning("No data found for this ticker"). Yahoo Finance uses uppercase tickers, so convert user input with ticker.upper() before fetching.
RSI or MACD shows NaN values at the start—Technical indicators need a warmup period. The first 14 days of RSI will be NaN because the calculation requires 14 prior data points. Use df.dropna() before plotting or accept that early dates will show gaps. Document this behavior in your dashboard with st.info("Indicators require warmup period—first 14–26 days may show no data").
Streamlit reruns the entire script on every interaction—This is expected behavior. Every widget change triggers a full script rerun. Use @st.cache_data decorator on your data-fetching function to cache yfinance downloads and avoid redundant API calls: @st.cache_data def fetch_data(ticker, start, end): return yf.download(ticker, start=start, end=end). The cache persists across reruns as long as inputs don't change.
Best Practices
- Cache expensive operations—Wrap yfinance downloads and indicator calculations in
@st.cache_datato avoid recalculating on every widget interaction. This dramatically improves dashboard responsiveness when users toggle settings. - Validate ticker symbols before fetching—Check if the input is empty or contains special characters. yfinance does not throw errors for invalid tickers—it returns empty DataFrames silently.
- Show loading states—Use
with st.spinner("Fetching data..."):around slow operations so users know the dashboard is working, not frozen. - Add context with annotations—Include Streamlit markdown blocks explaining what each indicator measures:
st.markdown("**RSI below 30 suggests oversold conditions**"). Readers researching technical analysis benefit from inline explanations. - Version control your dependencies—Run
pip freeze > requirements.txtto lock package versions. yfinance updates frequently and API changes can break existing dashboards.
When Not to Use This
This approach is ideal for personal research, education, and prototyping trading ideas. It is not suitable for production trading systems or applications serving multiple users simultaneously.
Yahoo Finance data through yfinance is delayed and not guaranteed—the service can change or restrict access without notice. If you need real-time data, institutional-grade accuracy, or sub-second latency, use a paid market data provider with official APIs.
Streamlit's rerun-on-interaction model does not scale well for high-frequency updates or complex multi-user state management. For those cases, consider building a proper backend with WebSockets and a React or Vue frontend. If you are scheduling automated analysis jobs, Streamlit's interactive model is not the right tool—use headless scripts with scheduled execution instead.
FAQ
Can I deploy this dashboard to the cloud?
Yes. Streamlit offers Streamlit Community Cloud for free hosting of public apps. Push your code to a GitHub repository, connect it to Streamlit Cloud, and deploy in minutes. The platform handles scaling and SSL certificates.
For private dashboards, use Heroku, AWS, or Google Cloud Run with a Dockerfile. Include your requirements.txt so the platform installs dependencies automatically.
How do I add more technical indicators like Bollinger Bands or Stochastic Oscillator?
Follow the same pattern as RSI and MACD. For Bollinger Bands, calculate the 20-day SMA and standard deviation: sma = df['Close'].rolling(window=20).mean(), std = df['Close'].rolling(window=20).std(), then upper_band = sma + (2 * std) and lower_band = sma - (2 * std).
Add them as new traces in your Plotly chart. The yfinance documentation shows available data columns you can use for custom calculations.
Does yfinance work with cryptocurrencies or forex?
Yes. Yahoo Finance provides data for major cryptocurrencies using tickers like BTC-USD, ETH-USD. Forex pairs use symbols like EURUSD=X. The same yfinance code works—just pass the appropriate ticker.
Be aware that crypto data may have gaps during exchange outages, and forex data availability varies by currency pair.
Can I backtest trading strategies with this dashboard?
Not directly. This dashboard visualizes indicators but does not simulate trades or calculate portfolio returns.
For backtesting, extend your code to generate buy/sell signals based on indicator crossovers, then calculate hypothetical profit/loss over the historical period. Libraries like backtrader or vectorbt handle backtesting logic. You can use your Streamlit dashboard to visualize backtest results, but the strategy simulation happens in separate Python functions.
The next step—if you want to move from visualization to testing actual trading rules—is deciding which crossover signals to trust and which to ignore. That question requires more than a dashboard. It requires judgment about market conditions, risk tolerance, and whether a pattern that worked in 2019 still works now.
