Video summary

2026 FREE Data Analyst Bootcamp [24 Hours+] for FREE | SQL, Excel, Python, Power BI, GitHub, AWS

Main summary

Key takeaways

Educational

Overview of the 2026 Free Data Analyst Bootcamp

The video presents an updated, expanded version of a creator’s earlier 2024 “data analyst bootcamp” (around 24–25 hours), now extended into a much broader learning track.

It adds new and organized learning playlists, including:

  • Data fundamentals
  • Git + GitHub
  • R for data analysts
  • Databricks (with ETL pipelines)

It also lays out a clear “how to become a data analyst” skill path, transitioning from learning core tools to building projects, preparing hiring materials, and applying for roles.

Core Roadmap: Skills → Projects → Resume → Applications

The bootcamp emphasizes a step-by-step workflow:

  1. Learn the core data analyst skill stack in a recommended order
    • SQL first (foundational and interview-common)
    • then a BI tool (Tableau or Power BI) for visualization and dashboards
    • then Excel for cleaning and analyst-ready modeling/visuals
    • then Python later (powerful, but often harder to start)
    • finally move toward a cloud platform (AWS/Azure/GCP), especially via hands-on work
  2. Build portfolio-worthy projects to demonstrate competence.
  3. Create a data analyst resume, placing skills and projects near the top—especially important for those without direct experience.
  4. Apply effectively, using recruiters (with LinkedIn highlighted as particularly effective).
  5. Interview and accept an offer once received.

Data Fundamentals: Building Blocks for Analysis

The fundamentals section defines key concepts and how they relate:

  • Data vs context: raw facts become useful when placed in the right context.
  • Data types: strings, numbers, and dates/times; plus structured vs unstructured formats.
  • File types/formats: common examples include CSV, text, XLSX, databases, JSON, XML, images (e.g., MP4), and parquet for big data contexts.
  • Data collection and pipelines / ETL: how data gets gathered and moved.
  • Data cleaning: fixing “dirty data” so it is accurate, consistent, and complete.
  • KPIs vs metrics: not every metric is a KPI—KPIs are tied to business goals and should be actionable.

The video also provides a practical way to select KPIs:

  1. Identify the business goal
  2. Pick the metric that best tracks progress
  3. Confirm it’s actionable (something the team can realistically influence)

MySQL Curriculum and Project Work

A major portion of the bootcamp covers a structured MySQL beginner-to-advanced curriculum, including:

  • Query foundations: SELECT, DISTINCT, WHERE filters (operators, logical conditions, and LIKE)
  • Aggregation: GROUP BY with aggregate functions
  • Result ordering: ORDER BY
  • Correct filtering logic: HAVING vs WHERE
  • Pagination and clarity: LIMIT and aliasing
  • Relational reasoning
    • Joins (inner/left/right/full outer, plus self joins, and joining multiple tables)
    • UNION / UNION ALL, including labeling examples
  • Text/string functions: length, upper/lower, trim, substring, replace, locate, concat
  • CASE statements
  • Subqueries in WHERE, SELECT, and FROM
  • Window functions (partitioning, row_number, rank, dense_rank, rolling totals)
  • Advanced techniques: CTEs and temporary tables, plus stored procedures, triggers, and scheduled events

MySQL Project 1: Data Cleaning Methodology (and Execution)

The cleaning project follows a repeatable pipeline:

  • Create a new schema/database and import the dataset.
  • Copy data into a staging table to protect the original.
  • Remove duplicates using windowing/row-number logic
    • if deletion from a CTE is limited, copy into a second staging table and delete using row numbers
  • Standardize columns
    • trim whitespace
    • normalize inconsistent values/spellings (e.g., category naming like “crypto” vs “cryptocurrency”)
    • fix country formatting
    • clean using string operations
  • Handle nulls/blanks
    • convert blanks to NULL
    • fill missing categorical values when matching non-null rows exist
    • make explicit decisions for records missing critical numeric fields (the project deletes rows with missing key totals/percentages)
  • Convert date strings to proper DATE using STR_TO_DATE, then alter column types.
  • Drop helper columns (like row_num) after completion.

MySQL Project 2: Exploratory Data Analysis (EDA) Methodology

The EDA project focuses on analysis patterns that produce chart-ready outputs:

  • Check max/min of numeric columns.
  • Filter to key severity cases (e.g., rows where the layoff percentage is 100%).
  • Use GROUP BY aggregations (company, industry, country) with sums and date min/max.
  • Perform time analysis by grouping by year (and later month), then compute rolling totals with window functions.
  • Rank results using dense/rank logic via CTEs to identify top-N companies per year.
  • Structure outputs for dashboard visualization (company, year, totals, ranks).

SQL Interview Practice: From Easy Filters to Window Functions

Beyond the bootcamp curriculum, the video includes a practice-focused SQL segment covering common interview patterns:

  • Easy questions (filtering logic)
    • car pass/fail logic using multiple conditions and mapping “OR” in fail descriptions to the correct pass requirement
    • counting customers matching either qualifying condition, including careful attention to strict “over” vs >=
  • Medium questions
    • percentage computation using grouping, ROUND(..., 2), and ordering
    • splitting fixed-format combined identifiers using substring extraction
  • Hard / very hard questions
    • window functions (e.g., ROW_NUMBER) to find the “third purchase” per customer, with the note that window functions often require wrapping via subquery/CTE before filtering
    • “compare with previous day” logic using self-joins (or lag-like alignment) and filtering where today exceeds yesterday
    • complex address parsing using substring indexing and delimiter logic, including unit/suite removal and trimming hidden whitespace

Excel, Tableau, and Power BI: Turning Data into Dashboards

Excel

Excel lessons cover core analytics workflows:

  • Pivot tables (drill-down style layouts)
  • Formula skills:
    • MAX/MIN, IF/IFS
    • text functions (LEFT/RIGHT, YEAR extraction, TEXT formatting, TRIM, CONCATENATE, SUBSTITUTE)
    • SUM/SUMIF/SUMIFS, COUNTIF/COUNTIFS, and NETWORKDAYS
  • Lookup improvements with XLOOKUP
  • Conditional formatting (gradients, rules, duplicates, “text contains”, custom formula rules, and rule management)
  • Charts (column/line/pie/donut) with formatting guidance
  • Excel cleaning patterns: deduplication, case standardization, trimming, currency/date normalization, dropping unused columns
  • A final Excel dashboard project: clean data → pivots → visuals → slicers → formatting into an interactive dashboard

Tableau

Tableau lessons include:

  • Installing Tableau Public
  • Core concepts: dimensions vs measures, marks, color encodings, filters
  • Binning and calculated fields
  • Visuals such as scatter plots and maps
  • Tableau joins
  • A final Airbnb project combining multiple tables (calendar/listings/reviews), then producing a dashboard with map, time series, bedrooms, and competition counts

Power BI

Power BI lessons include:

  • Desktop setup and loading Excel
  • Power Query transformations (remove rows, promote headers, unpivot, change data types, filter)
  • Relationships: cardinality and cross-filter direction
  • DAX basics:
    • measures using COUNT and SUM
    • row-level vs aggregated logic (introducing SUM vs SUMX conceptually)
    • date functions (weekday)
    • IF logic for categorical labels
  • Drill-down using hierarchies
  • Conditional formatting in matrices/tables (backgrounds, data bars, icons)
  • Bins and list-style grouping
  • A comprehensive overview of visualization types
  • A final Power BI project:
    • ingest survey data
    • split/simplify messy multi-option fields via Power Query
    • build dashboard tiles/charts using multiple visual styles

Python Series: Data Manipulation and Automated Data Collection

Python content includes:

  • Environment setup (Anaconda + Jupyter)
  • Core programming:
    • variables, data types (numbers/booleans/strings/lists/tuples/sets/dictionaries), naming/case sensitivity
    • operators (comparison/logical/membership)
    • control flow: if/elif/else, for, while (including break/continue/else)
    • functions and arguments patterns (*args, **kwargs)
    • type conversion

Mini projects include:

  • BMI calculator with category logic
  • Windows file auto-sorting tool
  • Web scraping with BeautifulSoup:
    • scrape a Wikipedia table into a Pandas DataFrame and export to CSV
  • Amazon price tracker:
    • scrape title/price, write CSV, append over time in a loop with delays, optionally email when a threshold is hit
  • Crypto API automation:
    • fetch API data (e.g., CoinMarketCap-like), normalize JSON, add timestamps, loop and append to frames/CSV, reshape/group to visualize percent changes across time windows

Cloud Foundations and ETL/Orchestration: Azure, AWS, and Databricks

Azure

The Azure workflow begins with prerequisites (Microsoft account + Azure account), including free/trial options such as “popular services free for 12 months” and “55 services always free,” with notes about payment verification to protect credit usage.

Key topics:

  • Azure Storage accounts
    • blob containers for flexible file storage
    • tiers: Hot, Cool/Cold, and Archive
    • IAM role-based access control
  • Azure SQL Database
    • creation steps and authentication choices (Entra ID / SQL auth)
    • connecting via Azure Data Studio
    • managing public network access (allowed client IP when public access is disabled)
  • Azure Data Factory (ADF)
    • ingestion, data flows for transformation, orchestration
    • managed identity permissions in SQL DB (granting roles to ADF identity)
    • reminder that debugging can cost money
    • dataflow transformations such as filtering and cleansing
  • Azure Synapse Analytics
    • combining ETL/workflows, querying, notebooks (SQL and Spark), and visualization
    • integration with Data Lake Storage Gen2
    • Spark pool sizing considerations and pipeline-like copy operations between locations
    • collaboration/sharing within the workspace

AWS

AWS setup includes account creation and choosing regions for latency.

Key topics:

  • S3 buckets
    • unique naming, general-purpose configuration
    • public access disabled
    • optional encryption/versioning choices
  • Storage classes
    • Standard (fast access)
    • Glacier deep archive (low-cost, restore required)
  • S3 Select
    • query inside CSV without full ETL

Then Athena:

  • SQL querying directly on data in S3
  • requires catalog/database/table definitions and a dedicated query result location in S3
  • table creation with manual column typing and careful partition/path selection to avoid metadata-file pollution
  • cleanup by storing results in a dedicated folder
  • limitation note: best for quick insights rather than heavy production workloads

Then Glue and Glue DataBrew:

  • DataBrew:
    • visual recipe-based transformations
    • job outputs to S3 (with default multi-file outputs that can be adjusted)
  • Glue catalog via crawlers to infer schemas/tables from S3
  • ETL jobs with visual design (joins/unions/aggregations)
  • common failures:
    • IAM permission problems
    • serialization/compression formatting choices (CSV vs Parquet + compression)

Finally, QuickSight:

  • dashboards and interactive visual analytics
  • dataset concepts (including possible SPICE in-memory acceleration)
  • sharing/publishing dashboards and embedding

Databricks (Data Engineering + AI-assisted Coding + ETL Pipelines)

Databricks covers a free-edition style Spark environment with workspace components:

  • Catalog
  • Jobs/pipelines
  • Compute
  • SQL editor
  • Notebooks
  • AI features (Genie and assistant tools), plus dashboards/alerts

It covers:

  • Ingesting data
    • catalogs/schemas, upload to volumes, query files directly, create tables
    • connect external sources (example: Google Drive synced into a table)
  • Dashboards
    • prepare visualization datasets using SQL and add charts
    • note: global filters only apply when widgets are tied to datasets containing the filter field
  • Genie / AI assistant
    • natural-language Q&A over data
    • generating SQL and visualization suggestions
    • improving code (explain, optimize formatting, fix errors, add comments)
    • assisting in notebooks across Python/SQL

Medallion ETL Pipeline Architecture in Databricks

An ETL example demonstrates bronze → silver → gold:

  • Bronze: raw, potentially dirty ingested data
  • Silver: cleaned/standardized tables
    • convert messy date strings to timestamps
    • remove duplicates based on user ID
    • standardize/clean columns, then save as silver tables
  • Gold: business-ready aggregates/insights
    • example: derive best day-of-week for ad clicks/signups and referral breakdowns

It also explains:

  • Notebooks (straight execution)
  • ETL pipelines (data quality checks, lineage, incremental patterns, dependencies, and framework requirements for outputs)

Orchestration, Scheduling, and Automation

The section concludes with Databricks Jobs orchestrating notebooks/queries with:

  • time-based schedules
  • table update triggers
  • job configuration features like retry logic and notifications
  • an end-to-end automation example triggered by new S3 file arrivals every 30 minutes:
    • stream ingest into a transactions table
    • trigger pipeline on table updates
    • write bronze/silver/gold outputs
    • validate row counts and cleaning correctness (e.g., product naming consistency)

R Setup and Core Data Analysis Programming (R Studio Series)

The bootcamp includes an R track:

  • install R and RStudio (Posit)
  • basic RStudio layout:
    • editor pane
    • console/errors
    • environment viewer
    • file browser

Core R concepts:

  • variables and data types (vectors, lists, data frames)
  • arithmetic operators and order of operations
  • comparison and logical operators (&, |, !)
  • reading/writing files with read.csv() and write.csv():
    • Windows path/escaping considerations
    • parameters like header, sep, row.names

Data manipulation with dplyr:

  • select(), filter(), arrange(), and piping via %>%

Grouping/aggregation:

  • group_by() + summarise() using mean/median/min/max/count (n)
  • emphasis that mean vs median changes how outliers are treated

Missing data handling:

  • convert blanks to NA
  • drop rows with required missing values (e.g., missing email)
  • impute numeric missing values by replacing NA with 0

Resume-Building Guidance and ATS Compatibility (Hiring Focus)

The video targets career readiness:

  • a resume ordering strategy for beginners/no experience:
    • put name + contact + LinkedIn/GitHub at the top
    • place skills near the top using specific tech names (e.g., “SQL — SQL Server, MySQL, PostgreSQL”; “Python — pandas”) rather than vague buzzwords
    • highlight projects with what you did + what tools you used, and include keywords (ideally with hyperlinks)
    • place unrelated work experience lower, tailoring bullets to analytics-adjacent skills and prioritizing recent roles
    • keep education toward the bottom, typically without GPA (include only high-value certifications)
  • using ChatGPT to draft resume/project descriptions and generate phrasing ideas (without blindly copy-pasting)
  • ATS compatibility:
    • use clean, bullet-based, standard formatting
    • avoid complex designs that can break parsing

Overall, the video functions as an end-to-end bootcamp: defining the path to learn analyst tools, teaching SQL/Python/R plus BI visualization workflows, demonstrating real ETL pipeline patterns in the cloud (Azure/AWS/Databricks), and pairing the technical curriculum with practical hiring materials like ATS-friendly resumes and recruiter-focused application strategy.

Original video