Guided production scenarios with step-by-step environments.
Every analysis follows the same loop: frame the question, gather data, clean it, explore, analyze, communicate, and measure. The workflow is what makes analysis reproducible.
A metric is a measurement of an activity; a KPI is a metric tied to a strategic objective with a target. Good metrics are comparable, actionable and resistant to gaming.
Excel remains the fastest tool for quick analysis: absolute references, named ranges, tables and date/number formatting turn a sheet into a controllable calculation model.
VLOOKUP, INDEX/MATCH, XLOOKUP and the new dynamic-array lookups let one table be enriched from another. XLOOKUP is the modern default; INDEX/MATCH still wins for right-side and two-way lookups.
Pivot tables summarize tabular data into rows, columns, values and filters without formulas. Slicers, timelines and pivot charts turn them into self-serve dashboards.
Power Query is Excel's ETL engine: repeatable steps to import, clean, reshape and merge data, captured as queries that replay on every refresh.
SQL is the lingua franca of analytics: a declarative language that selects, filters, joins and aggregates data in the warehouse. You describe what you want, not how to compute it.
GROUP BY turns rows into summaries: counts, sums, averages, min/max and distinct counts, plus window-style totals. Getting aggregation right is the core of analytical SQL.
Joins combine tables on a key: inner keeps matches, left keeps all left rows, and the JOIN type plus key cardinality decide whether rows multiply. Getting joins right prevents the classic 'doubled revenue' bug.
Window functions compute values across a sliding frame over rows — running totals, rank, lag, moving averages — without collapsing rows like GROUP BY. They're the engine of cohort, funnel and trend analysis.
Common Table Expressions (WITH clauses) name intermediate steps so complex analytics read top-to-bottom. They are the closest SQL gets to building blocks — readable, composable and testable.
Descriptive statistics summarize a sample: central tendency (mean, median, mode), dispersion (variance, standard deviation, IQR) and shape. They are the grammar of every chart and the foundation of inference.
Real-world data forms recognizable shapes: normal, binomial, Poisson, exponential, log-normal. Identifying the shape tells you which tests and models are valid and where the process behaves.
Hypothesis testing formalizes 'is this difference real?': null vs alternative hypotheses, test statistics, and p-values that measure evidence against the null — the statistical engine behind A/B tests and analyst verdicts.
p-values measure evidence against a null in a given model. Multiple comparisons, p-hacking and threshold BS (mangrove at 0.05) make them dangerous; the fix is pre-registration, correction, and reporting effect sizes and CIs.
Python takes over where Excel and SQL stop: heavy computation, reshaping, automation and statistical modeling. The whole data stack — pandas, numpy, notebooks, orchestration — is one language.
Branches, loops and functions turn data manipulation into logic: iterate over rows, branch on conditions, and package reusable transformations with clear signatures.
Reading the right file type — CSV, JSON, Excel, plain text — is where raw evidence becomes analysis. pathlib and with-blocks keep file handling safe and portable.
map, filter, reduce, lambdas and itertools process data as transformations rather than step-by-step state — leading to cleaner, more composable analytics code.
The DataFrame is analytics' home base: labeled rows and columns that reshape, filter, group and join like a spreadsheet but at warehouse scale and in reproducible code.
Every analysis starts and ends at a boundary: read Excel, CSV, JSON and SQL into frames, then write summary tables back. Knowing the gotchas — encodings, separators, types — saves hours.
Filtering is the grammar of questions: 'who, what, where' maps to boolean masks, isin, query and multiple conditions — the skills behind every segment, cohort and targeted analysis.
GroupBy splits data by key, applies a function to each slice, and combines results — the engine of per-segment, per-cohort and per-date analytics.
Merging, joining and concatenating combine tables by key or by stacking — the mechanism behind enriched datasets: revenue + customers, events + entities, monthly files into one history.
Datetime indexes unlock resampling, rolling windows, lagged features and cohort timestamps — the machinery of month-over-month, trends, seasonality and 'same time last year'.
NumPy arrays are typed, dense, vectorized collections — the engine under pandas. Understanding arrays makes the whole data stack faster to reason about and to tune.
Broadcasting lets arrays of different shapes combine element-wise by aligning trailing dimensions — the trick that turns 'subtract each column's mean' into a one-liner.
Random sampling, seeding, and built-in statistical tools power simulations, bootstraps, and null distributions — the practical half of statistical inference.
Before analysis can be trusted, data must pass six quality gates: accuracy, completeness, consistency, timeliness, validity and uniqueness. Define them, measure them, then clean.
The absence of a value carries meaning. Detect it, model why it's missing, and handle it deliberately — drop, fill, flag or encode — so absence never silently skews results.
Exact, keyed, and fuzzy duplicates corrupt counts and inflate totals. Detection is a deliberate key decision; dedupe policy decides keep-first, keep-last, or aggregate.
Names, addresses, IDs and statuses arrive in a dozen costumes. Case folding, whitespace stripping, canonical value mapping and regex parsing turn messy strings into join-ready keys.
CSV brings strings, models want numbers, humans want dates, and money wants cents. Coercion with errors='coerce', datetime parsing, and units resolution happen once, at the boundary.
EDA is a disciplined conversation with the data before the analysis answers a question: shape, cleanliness, distributions, relationships, gaps — each inspected, each documented.
One variable at a time, told properly: categorical frequencies, numeric distributions, quantiles, and the story a histogram plus a box plot reveals.
Two variables, one question: does X move with Y? Cross-tabs for categories, scatter/grouped-box for numerics, correlation and segment-mixed means point to the hypotheses worth testing.
Missingness is a pattern, not a bug: examine it with null matrices, per-column budgets and by-group rates before any imputation or deletion decision.
Charts are the fastest eyes on unfamiliar data: distributions as histograms, relationships as scatters, segments as grouped bars, and staggered layouts that compare quickly and honestly.
Charts are arguments made visible. A few rules — start axes at zero, respect data-ink ratio, encode magnitude by length — produce charts readers trust faster than any fancy rendering.
The chart is the answer to the question: trends line/dot, comparisons bar/column, distribution hist/box, relationship scatter, part-whole stacked/bar. Match question to chart before aesthetics.
The workhorses of Python charts: matplotlib's primitives and seaborn's statistical defaults. Master the palette, the axes object, and the faceting API once.
A dashboard answers one question per screen, left-to-right: KPI header, trend context, then drillable slices. Structure, hierarchy and restraint beat decorations every time.
Power BI is a desktop-plus-cloud analytics stack: Power Query imports data, the data model holds relationships and DAX measures, and reports render in Power BI Service. Knowing which piece does which job is half the battle for new users.
DAX is a filter-language engine, not a row calculator. CALCULATE is the verb that rewrites the filter context, and knowing the difference between row context and filter context explains most measure bugs.
A Power BI model says how tables join and how filters flow. Star schemas, single active relationships and correct cardinality keep models fast and totals correct.
Time intelligence compares periods: same period last year, YTD, moving totals and shifts. All of it requires a proper date table and CALCULATE-driven measures.
Power BI ships a core visual library plus a matrix of custom and R/Python visuals. Choosing the right visual for the question is a design skill that reports live or die by.
Governance is who can build, publish, certify and audit. Workspaces, deployment pipelines, lineage and sensitivity labels make analytics clickable and safe at scale.
Tableau builds visuals by dragging fields onto shelves: rows, columns and marks. The data pane, worksheet and dashboard form the mental model every other Tableau skill hangs on.
Tableau connects to files, databases, and cloud sources. You can join tables, blend data sources, and union stacks; each approach differs in grain, relationships and performance.
Calculated fields extend your data in the view, and Level of Detail (LOD) expressions compute across any grain — fixed, include and exclude. LODs are the superpower for ratios and percentages.
Visual analytics is the deliberate pairing of a question and a chart: time uses lines, categories use bars, share uses treemaps. Tableau's Show Me plus marks, reference lines and dual axes make it fast to do well.
Publishing moves workbooks into Tableau Server or Cloud with permissions, data policies and refresh schedules. Governance is the invisible script that keeps shared analytics trustworthy.
A business metric is a number with a definition, a grain, an owner and a deadline. Metrics become KPIs when they gate decisions; the discipline is documenting how each is computed.
Revenue is not one number: MRR, bookings, billings, GMV and net revenue each answer a different question. Mixing them is the classic analytics crime against boards.
Event tracking is a data contract: consistent names, typed properties and a shared dictionary. Done well it makes every metric trustworthy; done badly it silently corrupts analysis.
AARRR — Acquisition, Activation, Retention, Revenue, Referral — is the classic framework that turns a product into a measurable lifecycle and shows where growth leaks.
Engagement is frequency, depth and breadth of usage — DAU/MAU, stickiness, session metrics and feature breadth. Engagement metrics must be defined with an explicit active-user definition.
Sample size is a function of baseline conversion, minimum detectable effect, significance level and power. Getting it right decides whether your experiment can ever see what you're testing for.
A p-value is the probability of seeing a result this extreme if there were truly no effect. It is not the probability the variant is better — a distinction A/B teams routinely botch.
A confidence interval shows the range of plausible true effects. Unlike a p-value, it communicates magnitude and uncertainty together — the practical tool for deciding whether an observed lift is big enough to matter.
Test enough segments and some will be 'significant' by chance. Multiple-comparisons control — Bonferroni, Holm, FDR — and disciplined pre-registration keep that fact from manufacturing fake insights.
The retention cohort matrix has cohorts in rows, periods-since-entry in columns, and percent-active cells. Reading it diagnosizes product health better than any single number.
Net revenue retention (NRR) tracks revenue from a starting cohort over time, net of churn, downgrades and expansions. Above 100% it means the base grows even without new sales — the most important SaaS habit signal.
The point of cohort analysis is a decision: which cohort pattern explains the gap, what change to make, and how to verify the change with a before/after cohort comparison.
A funnel is only as honest as its steps' events. Instrumentation decisions — what fires, when, dedupe keys, error retries — decide whether the funnel measures user behavior or server behavior.
Finding the biggest drop-off is step one; explaining it is the craft — time-between-steps, error events, exit reasons and segment splits turn a leak location into a fixable cause.
Funnel optimization is the loop of hypothesizing friction from drop-off evidence, testing a single change, and reading the funnel as the experiment's metric — with compounding gains available from multi-step funnels.
A retention curve plots retention over time. Its shape — steeply decaying, flattening, or flat — is the product's signature, and category curves give every company a truth-teller in the room.
Churn is retention's dark mirror. Voluntary vs involuntary, active vs passive, time-to-churn and churn reasons convert a rate into a set of fixable causes.
Improving retention is a system: pick the right horizon, admit experimentation's limits for long-term effects, use win-backs and micro-loops, and measure post-launch decay honestly.
RFM scores each customer on Recency, Frequency, and Monetary value, then groups them into segments such as champions, at-risk, and hibernating. It is the fastest way to convert a transaction table into actionable customer groups.
Customer lifetime value (CLV) is the present value of the profit a customer will generate over their relationship. It sets the ceiling for acquisition spend and underpins payback and LTV:CAC ratios.
Churn modeling predicts which users are about to leave so you can intervene early. It turns the retrospective churn rate into a per-user risk score and a ranked list for retention actions.
Segmentation splits customers into groups that differ on value, behavior, or needs; personas make those segments vivid and decision-ready. Together they turn one undifferentiated base into a handful of groups you can design for.
Forecasting predicts future values of a metric from its history, separating trend, seasonality, and noise. It turns calendar-aware data into a planning number that finance and ops can budget against.
Anomaly detection flags values that diverge from expected patterns — a crash in revenue, a spike in errors, a hung checkout. It replaces manual monitoring thresholds with statistically grounded alerting.
Bootstrap resamples your data thousands of times to estimate the uncertainty of any statistic. When the math of standard errors is hard, the computer draws the answer instead.
Data modeling layers are the onion of a warehouse: sources, staging, intermediate, and marts. Each layer has a job, and mixing responsibilities across layers is how warehouses go to war with themselves.
Data quality testing puts assertions on your warehouse: freshness, uniqueness, not-null, accepted values. A failing test pages the owner instead of letting bad numbers poison the dashboard.
Documentation and lineage turn a warehouse into a readable system: every model explained, every column described, every dependency drawn. New analysts onboard in days instead of forensic archaeology.
Analytics deployment moves warehouse models safely through environments — dev, staging, production — with previews, test gates, and rollbacks. It is how a data team ships changes without breaking the business's dashboards.
A dbt project is a folder with models, sources, seeds, macros, tests, and a series of configuration files. Naming and folder conventions make the warehouse readable and the dependencies obvious.
A dbt model is a SQL SELECT that dbt turns into a table or view. Models read from sources or other models via ref(), and their dependencies are resolved and documented automatically.
dbt sources declare where raw data lives, so models can read it with source() and dbt can check that it keeps arriving. Freshness checks turn 'the pipeline died' into an alert on the right page.
dbt tests are assertions on your models and sources — uniqueness, not-null, accepted values, and relationships. They run with every build and fail loudly on bad data.
Incremental models append only new rows instead of rebuilding every time. They keep big fact tables fast, but add a contract: a reliable way to detect what is new.
Dimensional modeling structures warehouse data into facts and dimensions: numbers you measure (facts) and the things you slice them by (dimensions). It is the most proven way to make a warehouse understandable.
A star schema arranges a single fact table surrounded by directly-joined dimension tables. It is the simplest shape a BI tool can consume: no fan-outs, no deep joins, glanceable queries.
Slowly changing dimensions (SCD) decide what happens to history when an attribute changes. Type 1 overwrites, Type 2 keeps a new row per version, Type 3 keeps prior and current. The choice determines whether past slices stay accurate.