# Python for Data Analysis → Deployable Dashboard: 3-Month Roadmap ## 1. Roadmap Overview **The transformation:** From zero code to independently building a `pandas` + Streamlit dashboard that reads a dataset, lets a user filter/interact with it, shows charts, and runs on a public URL. **Is it realistic?** Yes, but only if scope stays disciplined. You have ~78 hours (13 weeks × 6h). That is enough to reach *functional competence* aimed narrowly at one dashboard — not broad Python mastery. The word "mastery" in your prompt is the wrong target for 78 hours; "can build and deploy one simple dashboard unaided, and adapt it" is the right and achievable target. I'm keeping your stated goal but stripping every topic that doesn't serve it (no OOP theory, no algorithms, no web frameworks, no SQL). **Single biggest risk:** Not the coding — it's *time drag from getting stuck*. Beginners lose whole sessions to environment setup, cryptic errors, and version mismatches. At 6h/week there's almost no slack to absorb that. The plan mitigates this by front-loading a clean setup, keeping tools minimal (one plotting library, one dashboard framework), and reserving week 13 as buffer. The second risk is dashboard scope creep — wanting five features when one done well is the pass condition. ## 2. Prerequisites & Readiness Check No coding prerequisites — this is built for a true beginner. But close these *non-code* gaps before Stage 1: - **A working laptop you control** (can install software). Chromebooks/locked work machines cause pain. - **Comfort with files and folders** — knowing where a file is saved and how to navigate to it. This trips up more beginners than any Python concept. - **A spreadsheet mental model** — if you've ever used Excel/Google Sheets (rows, columns, filtering), you already have the intuition `pandas` builds on. If not, spend 30 min in a spreadsheet first. - **Basic English reading for docs/errors** — error messages and most tutorials are in English. (You clearly read English fine.) **Setup to complete in your first sitting (counts as part of Week 1):** Install Python via the official installer or Anaconda, install VS Code, and confirm you can run `print("hello")`. If setup eats more than 2 hours, switch to Google Colab (browser-based, zero install) for Stages 1–4 and only move local for the Streamlit stages. ## 3. Learning Stages ### Stage 1 — Python Fundamentals (the subset you actually need) **Goal & why:** You can't manipulate data without the basic grammar of the language. This exists to make the rest readable — but it's deliberately narrow. You need enough to read and write small scripts, not to become a software engineer. **Key concepts & skills:** Variables and types (int, float, string, bool); lists and dictionaries; `for` loops and `if`/`else`; writing and calling functions; importing libraries; reading error tracebacks. *Skip for now:* classes, decorators, comprehensions-heavy code, async. **Mastery difficulty: 5/10** — conceptually gentle, but the "everything is unfamiliar at once" effect makes early weeks feel harder than the score suggests. **Practical project:** A script that takes a hardcoded list of numbers (e.g. daily expenses) and prints the total, average, max, and how many are above average. **Self-check quiz:** 1. What's the difference between a list and a dictionary, and when would you use each? 2. Write a loop that prints only the even numbers from 1 to 20. 3. What does a `KeyError` mean and what usually causes it? 4. Why does `"3" + 3` fail but `3 + 3` work? **Common mistakes:** Confusing `=` (assign) with `==` (compare); indentation errors; copying code you don't understand; not reading the *last line* of the traceback first. ### Stage 2 — pandas Core: Loading and Selecting Data **Goal & why:** `pandas` is *the* tool for tabular data in Python and the engine under your dashboard. This exists so you can get real data into memory and pull out the pieces you want. **Key concepts & skills:** DataFrames and Series; `pd.read_csv()`; inspecting data (`.head()`, `.info()`, `.describe()`, `.shape`); selecting columns and rows (`.loc`, `.iloc`, boolean filtering); sorting. **Mastery difficulty: 6/10** — the `.loc`/`.iloc`/boolean-mask selection model is the first genuine conceptual hurdle. **Practical project:** Load a public CSV (e.g. a countries or sales dataset), and answer three questions with filtering — "which rows have value X above Y?", "what are the top 10 by column Z?". **Self-check quiz:** 1. Difference between `.loc` and `.iloc`? 2. How do you select all rows where `price > 100`? 3. What does `df.info()` tell you that `df.head()` doesn't? 4. What's the difference between a Series and a DataFrame? **Common mistakes:** Chained-indexing warnings; forgetting `pandas` is case- and type-sensitive on column names; assuming a filter modifies the original DataFrame (it usually returns a copy). ### Stage 3 — Cleaning & Exploratory Analysis **Goal & why:** Real data is messy — missing values, wrong types, duplicates. Dashboards break on dirty data, so this stage exists to make your data trustworthy. This is where most *analysis* actually happens. **Key concepts & skills:** Handling missing data (`.dropna()`, `.fillna()`); type conversion (`.astype()`, `to_datetime`); renaming columns; `groupby()` and aggregation; `.value_counts()`; creating new columns from existing ones. **Mastery difficulty: 7/10** — `groupby` is powerful but takes real practice to internalize, and cleaning requires judgment, not just syntax. **Practical project:** Take a deliberately messy dataset, clean it (fix types, handle missing values, standardize a text column), then produce a summary table using `groupby` (e.g. average value per category). **Self-check quiz:** 1. When would you `fillna` versus `dropna`? 2. Write a `groupby` that gives average sales per region. 3. Why might a numeric column load as text, and how do you fix it? 4. What does `df.duplicated().sum()` tell you? **Common mistakes:** Dropping rows silently and not noticing you lost half your data; filling missing values without asking whether that distorts the analysis; cleaning without keeping the raw file. ### Stage 4 — Visualization **Goal & why:** A dashboard *is* visualization plus interaction. This exists to turn tables into charts a human can read at a glance. Use **Plotly** (not Matplotlib) because Plotly charts drop straight into Streamlit and are interactive by default. **Key concepts & skills:** Bar, line, and scatter charts; choosing the right chart for the question; titles/labels/color; `plotly.express` one-liners like `px.bar(df, x=..., y=...)`. **Mastery difficulty: 4/10** — with `plotly.express` this is the easiest stage; the hard part is chart *choice*, not code. **Practical project:** From your Stage 3 cleaned data, produce three charts that each answer a specific question, with proper labels. **Self-check quiz:** 1. When is a line chart wrong and a bar chart right? 2. How do you set the axis titles in `plotly.express`? 3. What question does a scatter plot answer that a bar chart can't? **Common mistakes:** Chart junk (too many colors/3D); unlabeled axes; using a pie chart for more than ~4 categories. ### Stage 5 — Building the Streamlit Dashboard **Goal & why:** This is the target skill. Streamlit turns a Python script into a web app with no HTML/CSS/JavaScript — the only realistic path to "deploy a dashboard unaided" in your timeframe. This stage assembles everything prior into an interactive app. **Key concepts & skills:** `streamlit run app.py`; `st.title`, `st.write`, `st.dataframe`; widgets (`st.selectbox`, `st.slider`, `st.multiselect`); wiring a widget's value into a `pandas` filter so the app reacts; `st.plotly_chart`; layout (`st.sidebar`, columns); `@st.cache_data` for loading. **Mastery difficulty: 6/10** — Streamlit itself is friendly; the challenge is the "reactive" mental model (the whole script re-runs on every interaction). **Practical project:** The real deliverable — a dashboard that loads your dataset, has a sidebar filter (dropdown or slider), a data table that updates with the filter, and at least one chart that reflects the filtered data. **Self-check quiz:** 1. What happens to your script when a user moves a slider? 2. How do you connect a `st.selectbox` value to filter a DataFrame? 3. What does `@st.cache_data` do and why does it matter? **Common mistakes:** Not caching data loading (app becomes slow); over-stuffing one page; confusion about why the whole script re-runs on each click. ### Stage 6 — Deployment **Goal & why:** "Unaided" and "deploy" mean it must run somewhere other than your laptop. This exists to close the gap between "works on my machine" and "a link I can share." **Key concepts & skills:** A GitHub account and pushing a project; writing a `requirements.txt`; deploying free via Streamlit Community Cloud (connect repo → deploy); reading deployment logs when it fails. **Mastery difficulty: 6/10** — the code is done; the difficulty is Git/environment friction, the classic beginner wall. Rated moderate only because Streamlit's flow is unusually forgiving. **Practical project:** Get your Stage 5 dashboard live on a public URL and open it on your phone. **Self-check quiz:** 1. What is `requirements.txt` for and what breaks without it? 2. Why does it work locally but fail deployed? 3. How do you update the live app after changing code? **Common mistakes:** Missing/incomplete `requirements.txt` (top cause of failed deploys); hardcoded local file paths; committing huge data files. ## 4. Schedule Weekly granularity fits a 3-month span. ~6h/week, ideally split into two 3-hour or three 2-hour sessions — spacing beats one long block. | Week | Focus | Activities | Expected outcome | |---|---|---|---| | 1 | Setup + Python basics | Install tools (or Colab); variables, types, print; ~2h video + 2h typing code yourself | Runs scripts; understands variables | | 2 | Loops, conditionals | `for`/`if`; small exercises; **Stage 1 project part 1** | Can write a working loop with logic | | 3 | Functions + data structures | Lists, dicts, functions; **finish Stage 1 project**; Stage 1 quiz | Passes Stage 1 self-check | | 4 | pandas intro | DataFrames, `read_csv`, inspection methods | Loads a CSV and describes it | | 5 | Selecting data | `.loc`/`.iloc`/boolean filtering, sorting; **Stage 2 project** | Filters data to answer questions | | 6 | pandas consolidation | Stage 2 quiz; re-do exercises without notes; **review Weeks 1–3 (spaced)** | Selection feels automatic | | 7 | Cleaning | Missing data, types, duplicates | Cleans a messy dataset | | 8 | groupby + EDA | Aggregation, new columns; **Stage 3 project + quiz** | Produces a summary table | | 9 | Visualization | Plotly express charts; **Stage 4 project**; **review pandas (spaced)** | Three labeled charts | | 10 | Streamlit basics | Install, first app, widgets, `st.dataframe` | A running local app with a widget | | 11 | Interactive filtering | Wire widget → filter → chart; layout/sidebar | Filter changes table and chart | | 12 | Finish the dashboard | Polish, cache, `st.selectbox`/`slider`; **Stage 5 project done** | Complete local dashboard | | 13 | Deploy + buffer | GitHub, `requirements.txt`, Streamlit Cloud; fix issues | **Live public URL** | If you fall behind, cut Stage 4 to a single chart type and protect Weeks 10–13 — the dashboard is the goal, not chart variety. ## 5. Milestones & Progress Checkpoints - **End of Week 3 — "I can write Python":** *Done* = you write a 15-line script with a loop, a condition, and a function from scratch, no copy-paste, and fix your own typo-level errors. - **End of Week 6 — "I can wrangle a table":** *Done* = given an unfamiliar CSV, you load it and answer three filtering questions in under 20 minutes. - **End of Week 9 — "I can analyze and show data":** *Done* = you take raw messy data to a clean summary table and a labeled chart unaided. - **End of Week 12 — "I built a dashboard":** *Done* = the app runs locally, a filter changes both a table and a chart, no crashes on normal use. - **End of Week 13 — TARGET MET:** *Done* = a stranger can open your URL on their phone and use the filter. That's the whole goal. ## 6. Revision & Retention At 6h/week, forgetting is your enemy — new concepts pile on before old ones set. Build in spacing rather than hoping: - **Retrieval over re-reading:** end each session by closing everything and re-typing one thing you learned from memory. This single habit outperforms re-watching videos. - **Fixed spaced-review slots** (already in the schedule): Week 6 revisits Python basics, Week 9 revisits pandas. Spend the first 20–30 min of those weeks re-doing an *old* exercise cold, no notes. - **Weak-area log:** keep a running note of concepts that "didn't stick." Every second session, pull one from the list and re-practice it. Boolean filtering and `groupby` are the usual culprits — expect to revisit them. - **Error journal:** paste each new error message + the fix into a note. You'll see the same 10 errors repeat; recognizing them on sight saves hours. ## 7. Resources & Real-World Application **Resource types to seek (not specific courses — pick current, well-rated ones and verify versions against official docs, which change):** - *Stages 1–2:* one structured beginner-Python course you follow linearly (avoid hopping between five tutorials); the official `pandas` "Getting Started" tutorials. - *Stage 3:* short focused `pandas` cleaning/`groupby` tutorials + the `pandas` docs as reference. - *Stage 4:* the Plotly Express official gallery — copy an example, swap in your data. - *Stages 5–6:* the **official Streamlit docs and "Get started" guide** are unusually good — treat them as primary, and use their deployment guide for Streamlit Community Cloud (check it live, as the deploy flow updates). - *Throughout:* one AI assistant to *explain* errors — but write the code yourself. Having it write the dashboard for you defeats "unaided" and you'll fail the deployment stage where understanding matters. **Applying it to real problems — use data you care about**, which massively boosts persistence. Given your context, strong candidates for the dashboard dataset: - Your **guided-tour bookings or enquiries** (Béjar/Candelario) — a dashboard filtering by month/tour type/group size. - **Content or SEO metrics** across your client accounts — traffic or keyword-position tracking by client. - **PromptBase / Gumroad sales** — revenue by product over time. Any of these makes Week 13 produce something you'd actually reuse, not a throwaay exercise — which is the real test of "unaided": can you point it at *your* data next time, without a tutorial? --- One honest caveat: the tight point is Weeks 10–13. If life eats a week somewhere earlier, the right move is to compress Stage 1 (you only need the subset, not fluency) rather than rush the dashboard. Want me to turn Week 1 into a concrete day-by-day setup checklist so you don't lose your first session to installation?