The Data Analyst Bundle: Turn data into decisions leadership acts on, and become the analyst whose name comes up when titles and raises are on the table.

Description

SQL: Become the reviewer AI can’t replace, the one who catches the SQL that runs clean but quietly returns the wrong answer

This book trains you to be the reviewer of vibe-coded SQL, not to memorize the syntax. It starts from a different premise than every other SQL book: the agent writes the queries, and your edge is understanding what the database really does so you can review it with judgment the engine does not have. You’ll learn why a relational table is a set and why thinking in sets is the whole game, the order the engine actually evaluates a query in, how joins and indexes really execute and when an index is useless, the three-valued logic that makes NULL the most common silent-wrong-result bug in SQL, how to read a query plan as the ground truth the SQL hides, and how transactions, isolation, and migrations behave under real concurrency and scale, and you’ll learn all of it the way a reviewer needs it: by reading real queries the agent would generate and deciding what is good, what is plausible-but-dangerous, and what to push back on. The progression moves from reviewing a single query and a single index, to reviewing a schema and its constraints, to reviewing how the whole workload behaves under load and where it will fall over. There is almost no syntax drill here, and a great deal about the relational model, query execution, data integrity, and the specific ways an agent’s SQL goes wrong. For engineers who are going to vibe-code SQL either way and want to be the one who catches what the model missed.

AI DATA ANALYST: From SQL and statistics to data-driven decisions in the age of AI

This book trains you to be the reviewer and decision-maker over data, not to memorize another tool. It starts from a different premise than every other analytics book: the agent writes the queries, the pandas, and the first draft of the chart, and your value is the judgment the tool does not have. You’ll learn to frame the question behind the question a stakeholder actually asked, to interrogate whether the data can be trusted before you quote it, to follow a number back through the pipeline and the warehouse to where it could have broken, to define a metric so it means what you think it means, and to use only the statistics an analyst really needs. You’ll learn to design an experiment that can be believed, to read a p-value for what it does and does not license, to catch the bias, the confounding, and the Simpson’s paradox that flip a result, and to downgrade a correlation to the claim its design actually supports. Then you’ll learn to choose the chart that tells the truth instead of the one that flatters it, to turn a finding into a decision a busy executive will act on, and to handle user data within privacy law and without letting a biased model launder old harm into a new decision. The progression moves from reviewing a single number, to reviewing an experiment and an inference, to reviewing how the whole story reaches a decision and whether that decision is fair. There is almost no tool syntax here and a great deal about questions, trust, inference, communication, and the specific ways an agent’s analysis goes wrong. For the analyst who is going to vibe-analyze either way and wants to be the one who catches what the model missed.

PYTHON: Become the reviewer AI can’t replace, the one who catches the bugs that run but are wrong and signs off on what ships

This book trains you to be the reviewer of vibe-coded Python, not to memorize the language. It starts from a different premise than every other Python book: the agent writes the code, and your edge is understanding what that code really does so you can review it with judgment the interpreter does not have. You’ll learn what a name actually binds to and why aliasing and mutability cause the bugs they do, what a type hint does and does not enforce, what the event loop is really doing behind async and await, why the global interpreter lock means your threads are not the parallelism you think, what an ORM and a connection pool actually do, and how the pieces integrate into a running service, and you’ll learn all of it the way a reviewer needs it: by reading real code the agent would generate and deciding what is good, what is plausible-but-dangerous, and what to push back on. The progression moves from reviewing a single object and a single name, to reviewing a component like the data layer or the request pipeline, to reviewing how the whole system fits together and where it will break under real load. There is almost no syntax drill here, and a great deal about the object model, concurrency, failure, and the specific ways an agent’s Python goes wrong. For engineers who are going to vibe-code in Python either way and want to be the one who catches what the model missed.

VISUALIZATION: A practical guide to data visualization, from choosing the right chart to dashboards people actually read and act on

This guide shows you how to turn data into a picture that makes its point in seconds, so your analysis actually changes a decision instead of getting nodded at and ignored. It starts from the idea that every chart is an argument and builds the judgment to win it: how to choose the right chart for the question (comparison, trend, distribution, part-to-whole, correlation) instead of defaulting to a bar chart, how to use position, length, and color the way perception actually works, how to strip the chart down to its message by cutting the junk that hides it, how to use color with intent and stay readable for everyone, and how to avoid the distortions (truncated axes, dual axes, misleading area) that make a chart lie by accident. Then it builds up: designing a dashboard with a hierarchy people can scan, telling a story with a sequence of charts, and the honest line between a clear simplification and a misleading one. The book is tool-agnostic on purpose, with examples you can apply in any library or BI tool. It teaches you to make the right chart, remove what does not serve the message, and design for the reader under pressure, so your data gets believed and acted on. For analysts and engineers who want their charts to convince, not just exist.

ETL: A practical guide to building data pipelines, from extracting and transforming to loading, orchestrating with Airflow, and trusting the result

This guide shows you how to build data pipelines that a business can rely on, the kind that run every night, survive a bad source, and leave the warehouse correct instead of half-updated. It starts from the shape of the problem (extract from somewhere, reshape it, load it somewhere queryable) and builds the practices that separate a pile of cron scripts from a real pipeline: how to extract incrementally instead of reloading everything, how to transform in a way you can test and that fails loudly on bad data, the ELT-versus-ETL choice and when to push the work into the warehouse, idempotency and backfills so a rerun is safe and a gap is fillable, orchestration with Airflow (DAGs, schedules, retries, dependencies, and the gotchas), data quality checks that catch the broken load before the dashboard does, and the monitoring that tells you a pipeline silently stopped. The book does not tour every tool. It teaches you to design a pipeline that is incremental, idempotent, tested, and observable, so the numbers downstream are trustworthy and a 2 a.m. failure is a retry, not an outage. For engineers and analysts who move data and want it to arrive correct, on time, every time.

VIBE CODING: Become the programmer AI multiplies instead of replaces, the one who brings the judgment the machine still doesn’t have

This book reveals the secret that separates the developer AI replaces from the one it makes indispensable: vibe coding is not a collection of prompts, it’s software engineering with the AI inside the loop. On that premise, the book gives a chapter to each of the eight disciplines you have to bring to the table (strong fundamentals, AI-assisted coding, system design awareness, debugging depth, testing discipline, code review judgement, product understanding, and ownership of outcomes) and shows, in each, exactly where AI fails on its own and what your judgment adds so it doesn’t. It isn’t theory: every discipline lands in concrete scenarios, and the book closes with an operational kit (the costliest mistakes with their corrected version, prompt templates, checklists for before you prompt and before you merge, real before-and-after cases, and a one-page field manual) to keep beside you while you work. For engineers early in their career who want AI to multiply their value instead of making them disposable.

TABLEAU: Turn a pile of tables into the dashboard leadership opens every morning, make the numbers on it match the source of truth exactly, and become the analyst the room turns to when a decision is on the line

This book takes you from someone who can make a chart in Tableau to the analyst whose dashboards leadership opens every morning and acts on. It starts where the fear starts, with the dashboard that was wrong in the room, and builds the thing that stops it from happening again: numbers you can trace, a model that does not lie, and a view a director can use without you standing behind them. You will build one set of dashboards across the whole book, a real one for a SaaS company called Lumen, and take it from a pile of exported tables to the source of truth the leadership team plans against. You will connect to the data and decide, with reasons, when to extract and when to query it live, and build the data model so orders never fan out and inflate the totals. You will learn to pick the mark that answers the question instead of spinning the chart-picker roulette, and to build a dashboard that answers back, with filters, actions, and drill-down, so the director finds their own answer instead of messaging you. You will write calculations and level-of-detail expressions whose numbers reconcile with the source of truth to the cent, so the meeting where two dashboards disagree stops happening. And you will publish it to Server or Cloud, make it fast enough that nobody abandons it, and get it in front of the people who decide, with subscriptions that land the number in their inbox before they ask. By the end the dashboard is trusted, the numbers reconcile, it loads before anyone gives up on it, and when a decision is on the line the room turns to your view. For the analyst who has to build the dashboards the company runs on, and wants to be the reason it can run on them.

LOOKER: Define every metric once in a modeled layer so the whole company queries the same numbers, let people build their own dashboards without breaking the totals, and become the person nobody argues with about what revenue means

This book takes you from the person who writes every report to the person who owns the one definition everyone else builds on. It starts where the pain starts, in the meeting where two dashboards disagree, and builds the idea the whole book turns on: a metric should be defined once, in a modeled layer, and computed the same way everywhere it appears. You will build one real model across the book, for an online fitness-app company called Cadence, and take it from a pile of conflicting queries to a governed layer the whole company self-serves from. You will define dimensions and measures once in LookML so ‘active user’ and ‘monthly revenue’ mean exactly one thing, wire up the joins so an explore lets a non-technical colleague ask their own question without writing SQL, and build dashboards and reports people run themselves instead of queuing behind you. You will see why a governed metric beats everyone’s own number, and how to keep the layer honest as definitions change. Then you will make it reach further with Looker Studio, the free tool that turns a modeled source or a raw table into a shareable dashboard in minutes, with the sharing, embedding, and permission controls that decide who sees what. By the end, a metric means one thing, people answer their own questions, and when someone asks why revenue is what it is, the answer is in the model and not in your head. For the analyst who wants the whole company to trust one set of numbers, and wants to be the reason it can.

STATISTICS: Turn the numbers you pull into numbers you can defend, so the average stops lying to the room, the A/B test result holds up, and you become the analyst leadership believes when the decision is on the line

This book takes you from an analyst who can produce a number to one who can stand behind it in the room where the decision gets made. It starts where the pain starts, with a confident number that turned out to be a lie for the decision, and builds the six judgments that keep it from happening to you. You will work one running company across the whole book, Lumen, a subscription box business, and answer the questions its leadership actually argues about: what a Lumen user is really worth, whether the new onboarding flow moved anything, why churn spiked, and what next quarter looks like. You will learn to describe data honestly, so you know when the average is telling the truth and when the median or the whole shape is the only honest answer. You will learn that a number pulled from a sample is really a range, and how to say how wide that range is instead of quoting a single figure with false confidence. You will learn to tell a real difference from luck without drowning the room in jargon, what a p-value actually claims and what it does not, and how to design an A/B test that can answer the question before you spend six weeks running one that cannot. You will learn the trap that burns more analysts than any other, calling a correlation a cause and licensing a decision the data never supported, and how to spot it in your own charts before someone else does. And you will learn to build a model that both explains what drives churn and forecasts what is coming, honestly, with its uncertainty attached instead of hidden. By the end you will not just have the number. You will know how much to trust it, how to say that out loud, and how to be the person in the room whose numbers hold up after the meeting ends. For the analyst who is tired of hoping nobody asks the follow-up question, and wants to be the one who already has the answer.

METABASE: Turn a database nobody but you can read into dashboards the whole company opens on their own, stop being the person everyone pings to re-run the same report, and become the one whose numbers the business actually acts on

This book takes you from someone who can build a chart to someone who builds the dashboards a whole company self-serves on and trusts. It starts where the frustration starts, with the dashboard nobody used and the report you kept getting pinged to re-run, and it names the thing no Metabase tutorial does: the hard part was never the charts, it was making non-technical people able to answer their own questions and believe the answer. You will build one real Metabase across the book, for a home-goods retailer called Fernwood, and take it from a raw database only you can read to a set of dashboards the sales team, the ops lead, and the CEO open on their own every morning. You will connect Fernwood’s database and model a semantic layer on top of it, so people click on friendly names and clean columns instead of guessing at raw tables, and learn where the query builder is the right tool and where you drop to SQL. You will build questions and turn them into dashboards with filters and drill-through that answer what someone actually walked up wanting to know, so ‘show me last month’ or ‘why is this number down’ is a click, not a Slack message to you. You will define metrics once, so revenue means one thing company-wide, and wire up subscriptions and alerts so the dashboard comes to people instead of waiting to be visited. And you will make it self-serve and trustworthy: permissions so the right people see the right data, embedding so a dashboard lives inside another tool, and the performance work that keeps a shared dashboard fast when fifty people load it at nine in the morning. By the end nobody pings you to re-run a report, the numbers reconcile, and the dashboards are the thing people act on. For the analyst or engineer who has to make a company self-serve, and wants to be the reason it can.

DBT: A practical guide to turning raw warehouse tables into numbers people trust, by writing your transformations as version-controlled SQL models, layering staging into marts, testing the data before it ships, and deploying it all in CI like real software

This book shows you how to turn a warehouse full of raw tables into a set of numbers a company decides on with confidence. It starts from the mess most analytics lives in: correct SQL scattered across scripts and notebooks, with no order, no tests, and no way to reproduce it. Then it builds the discipline that separates that pile from a real analytics codebase. You will learn to write each transformation as a model, a plain SQL SELECT that dbt turns into a table or view, and let the tool work out the dependency graph so your models always run in the right order. You will layer raw sources into thin staging models that clean and rename, then into marts that hold the business definitions the whole company shares, so “revenue” and “active user” mean one thing in one place. You will write tests that fail the build when a key is not unique or a value goes null, and declare contracts so a column that changes shape upstream breaks the pipeline instead of the dashboard. You will get lineage and documentation for free from the code itself, and make the heavy models incremental so a nightly run costs minutes instead of a full rebuild. It closes on shipping this like software: version control, a pull request, a CI run that builds and tests every model on a sample before it reaches production, and the analytics-engineering role that owns the seam between the raw data and the number people trust. The book does not tour every dbt feature. It teaches you to build a transformation layer that is ordered, tested, documented, and deployed, so the figure on the dashboard is reproducible and defensible instead of a query someone ran once and hoped was right. For the analyst or engineer who wants to stop being the person the number depends on and become the one who built the system it comes from.

CLAUDE: Stop treating Claude Code like a chatbot that happens to write code and learn to drive it like the agentic engineer it is, across the terminal, your editor, the desktop, and CI, so it ships a day’s work in an hour without leaving you a mess to clean up

This book teaches the durable skill under Claude Code: not a list of features that will have moved by next quarter, but how to drive an agentic coding tool so it does real work you can trust. It starts where the pain is (the day it saved you and the day it burned you) and then walks the seven moves that separate the operator from the person the tool runs circles around. You will set it up across every surface and know when to reach for the terminal, when for your editor, when for the desktop app, and when for the browser. You will give it the context once (a project memory file, the repo, a plan agreed before it touches code) so it stops re-asking and stops guessing. You will drive a single task the right way, reading the diff and steering, so a good change never turns into a bad sprawl. You will set permissions so it flies on the safe work and stops at the dangerous work, decide what to auto-approve and what to gate. You will run work in parallel (subagents, several sessions, isolated worktrees) without the pieces colliding. You will extend it with the connectors, hooks, and commands that make it fit your stack. And you will put it in CI so it reviews, fixes, and answers issues on its own while you are not watching. It closes on what you become once this is second nature: the engineer who ships more, trusts the output, and is worth more because the machine multiplies your judgment instead of your mess. For the engineer who wants Claude Code to feel like a real edge, not a slot machine.

COMMUNICATE: The status update nobody has to chase, saying you are blocked before it costs a week, giving an ETA you keep honest, surfacing bad news while it is still small, and telling the story of your work so the people who decide raises can finally see it

This book is about the skill that decides whether your good work is ever seen: telling the people around you what is going on, regularly and honestly, before they have to ask. It starts from an uncomfortable truth. Two engineers do equally good work; the one who communicates it clearly gets trusted, promoted, and paid more, and the one who stays quiet gets passed over, and this is not unfair, it is a signal the quiet one never sent. From there it lays out a small operating system of honest communication you can run for the rest of your career. You will learn to build the update nobody has to chase, on a rhythm that makes your manager stop wondering where you are. You will learn to say you are blocked the moment you are blocked, instead of hiding it until it is a crisis, and why the engineer who asks early looks stronger, not weaker. You will learn to give a date you actually believe and to update it the instant it slips, so your word stays worth something. You will learn to surface bad news while it is still small, in the shape that makes people trust you more for having told them. You will learn to write the way a busy executive reads, so the one thing that matters lands in the first line and the ask is impossible to miss. And you will learn to make your work visible without bragging, by telling the story of what changed because of it, and to disagree in a way that gets you respected and on the record instead of resented. Each rule is one habit, framed so you know exactly what it looks like when you are doing it right. It closes on the engineer you become when none of this is effort anymore: the one leadership trusts with the important thing, because they always know where it stands. For the engineer who is tired of watching worse communicators get ahead, and is ready to become the one nobody has to chase.