Video summary

End to End SQL Portfolio Project for Data analyst | SQL Project for Resume

Main summary

Key takeaways

Product Review

Product reviewed (from the subtitles)

The video is not reviewing a single packaged hardware/software product. Instead, it teaches and walks through an end-to-end SQL portfolio project (for data analysts/data scientists) that includes:

  • Building a small database from 3 CSV files
  • Creating 3 SQL tables with foreign-key relationships
  • Writing 20 SQL queries total:
    • 11 basic queries
    • 9 advanced queries
  • Covering common SQL interview portfolio skills such as joins, aggregates, filtering, grouping, HAVING, and more complex “window-like” patterns using logic

Domain / dataset: Online book store

The project uses an online book store dataset with these tables:

  • Books: book catalog with genre, author, year, price, stock
  • Customers: customer demographics (name/email/phone/city/country)
  • Orders: order details (order_id, customer_id, book_id, order date, quantity, total/amount)

Main features / what the project includes

  1. End-to-end setup

    • Import three CSV files into SQL
    • Create tables with appropriate column types
    • Add foreign keys:
      • Orders references Customers and Books

  2. Resume/portfolio-ready

    • The author emphasizes it can be showcased on resume/GitHub.

  3. Database schema + relationships

    • Requires common columns with the same name + datatype across CSVs (notably book_id and customer_id).

  4. Query set (20 queries)

    • Builds from basics into multi-table analytics.
    • Demonstrates:
      • WHERE filtering (case sensitivity mentioned for genre)
      • BETWEEN for date ranges (e.g., Nov 2023)
      • Aggregates like SUM for stock and revenue
      • Sorting/limiting: ORDER BY ... DESC/ASC, LIMIT
      • DISTINCT for unique genres/cities
      • JOIN across Books, Orders, and Customers
      • GROUP BY + aggregates grouped by genre/author/year/customer
      • HAVING for “at least two orders” logic
      • More complex analytics (top expensive, most frequent book, remaining stock after sales, etc.)

  5. Special advanced logic: remaining stock

    • Computes: Remaining stock = stock - total ordered quantity
    • Uses:
      • LEFT JOIN + aggregation
      • Conditional handling via COALESCE (mentioned) so that books with zero orders keep remaining stock equal to the original stock

Pros (benefits mentioned)

  • Practical interview preparation for aspiring analysts/data scientists
  • Structured learning path, framed as a “final project” (within a 30-day SQL course context)
  • Realistic portfolio value: includes a full set of queries you can reuse for GitHub/resume work
  • Teaches common SQL pain points:
    • Foreign-key creation order (create referencing tables last)
    • Import path slash issues (forward vs backward slashes)
    • Debugging query/import errors while practicing
  • Covers frequent interview patterns:
    • Joins + grouping + HAVING + top-N problems + revenue/customer spend analytics
  • Includes an advanced query (remaining stock) that tests deeper SQL reasoning

Cons / limitations (as implied by subtitles)

  • No product-grade rating/score is provided (no numeric evaluation of quality/usability)
  • Setup can be error-prone for beginners:
    • Import path slash mismatch
    • Foreign key dependency errors when creating/dropping tables in the wrong order
    • Some instruction details imply copy-paste vs typing differences, requiring manual corrections
  • No SQL file is provided in-video:
    • The speaker mentions they provide full code and practice CSVs, but “not the SQL file”
  • The repeated coaching/troubleshooting suggests it may take significant time to get running correctly

User experience / how it feels to follow

The walkthrough is step-by-step and includes:

  • Instructions for table creation (columns, data types, constraints)
  • Data import instructions for three CSVs
  • Guidance for writing each query across both basic and advanced parts

The speaker emphasizes practice and error-solving, such as:

“Try to solve the error”

Comparisons made

  • No direct comparison to other tools/products is present.
  • Comparisons are internal to the curriculum:
    • Basic vs advanced queries (11 vs 9)
    • Query difficulty increases gradually through operators like WHERE, BETWEEN, ORDER BY, DISTINCT, HAVING

Key unique points mentioned (complete list)

  1. 30-day SQL course context: this is the “end” project after 29 daily lessons
  2. Uses three CSV files: Books, Customers, Orders
  3. Tables must share common columns (same name + datatype) to relate them
  4. Relationships via foreign keys:
    • Orders → Customers
    • Orders → Books
  5. Dataset availability: links provided (GitHub + Drive mentioned)
  6. Query plan:
    • 20 total queries: 11 basic + 9 advanced
  7. Basic query examples include:
    • Filter fiction genre (WHERE genre = 'Fiction', spelling/case noted)
    • Publish year > 1950
    • Customers from Canada
    • Orders placed in Nov 2023 using BETWEEN on order_date
    • Total stock using SUM(stock)
    • Most expensive book using ORDER BY price DESC + LIMIT 1
    • Customers who ordered quantity > 1
    • Orders where total_amount > 20
    • Distinct genres
    • Lowest stock book using ORDER BY stock ASC + LIMIT
    • Total revenue using SUM(total_amount) (from orders)
  8. Advanced query examples include:
    • Total books sold per genre using JOIN + GROUP BY genre
    • Average price in Fantasy genre using AVG(price) + genre filter
    • Customers with at least two orders using HAVING COUNT(order_id) >= 2
    • Most frequently ordered book (by book_id) + ORDER BY ... DESC + LIMIT 1, optionally joined to fetch the title
    • Top 3 most expensive Fantasy books (LIMIT 3)
    • Total books sold by each author (join + group)
    • Cities of customers who spent >= $30 (DISTINCT city)
    • Customer who spent the most (join + group + ORDER BY SUM(total_amount) DESC + LIMIT)
    • Remaining stock after fulfilling all orders:
      • LEFT JOIN Books → Orders
      • conditional logic with COALESCE for missing orders as 0
      • SUM(Orders.quantity) per book, then books.stock - total_quantity
  9. Foreign key behavior emphasized:
    • dropping a parent table fails if dependent children exist
    • since Orders depends on Customers/Books, drop the order table first
  10. Course certificate requirements:
    • complete an assignment (10 questions, likely SQL-based)
    • submit a PDF response and provide a LinkedIn post link for verification
  11. AI suggested to generate a LinkedIn post and produce a PDF answer sheet

Speakers / multiple perspectives

Only one primary speaker appears in the subtitles (no clear multi-speaker sections). All points seem to come from the same instructor.

Concise verdict / recommendation

Recommendation: Yes—if you want an interview/portfolio-style SQL project.

The video provides a complete end-to-end workflow (data import, schema with relationships, and a set of 20 interview-relevant queries including advanced analytics like customer spend and remaining stock after orders). The main drawback is that beginners may need time to debug setup issues (foreign keys, import paths, and query errors), though the walkthrough is designed to help through hands-on practice.

Original video