← All courses

Beginner to intermediate

Database Foundations: SQL, Design, and Scale

Learn database fundamentals, relational modeling, PostgreSQL SQL, transactions, performance, and when NoSQL or scale-out designs fit.

For Learners who want to understand databases and build reliable relational data applications

What you will learn

  • Explain what a DBMS does and compare relational and common NoSQL models.
  • Model entities, keys, relationships, and constraints in a relational schema.
  • Use PostgreSQL DDL and SQL CRUD, joins, aggregates, subqueries, and CTEs.
  • Recognize normalization trade-offs and use transactions to protect multi-step work.
  • Read a basic query plan and explain the costs and uses of indexes.
  • Describe views, functions, procedures, triggers, and common scaling choices.

Where to use these skills

  • Design relational schemas for applications with connected records.
  • Write SQL to define, read, create, update, and delete data.
  • Understand transactions, indexes, query plans, and database trade-offs.

What this course does not cover

  • This course is not a vendor certification guide or a complete database administration manual.
  • Examples use PostgreSQL; syntax and procedural languages vary across database products.

This course takes a practical path from database concepts to SQL used in applications. A small shop schema—customers, products, orders, and order items—provides a consistent example across chapters.

The SQL examples target PostgreSQL. Core relational ideas transfer broadly, but data types, identity columns, pattern matching, stored-program languages, and some administrative commands differ by product. The examples use PostgreSQL-specific syntax where needed and call out important portability limits.

No prior database experience is required. Basic comfort reading code and tables is helpful. Follow the chapters in order, try the queries in a local PostgreSQL database, and use the final chapter as a searchable SQL reference.

A roadmap from database concepts and relational design through SQL, transactions, performance, and scaling

The relational-versus-document comparison is informed by the GeeksforGeeks DBMS topic guide and MongoDB's data-modeling guide.

Course chapters

  1. 01Databases, DBMSs, and data modelsUnderstand what a database system does and how relational and NoSQL models differ.
  2. 02The relational model and relationshipsTurn real-world concepts into related tables with keys and clear relationship rules.
  3. 03Create tables with types and constraintsUse DDL to define a small relational schema and let the database enforce its rules.
  4. 04CRUD and basic SQL queriesRead and change table data with SELECT, INSERT, UPDATE, and DELETE.
  5. 05Join related tablesCombine rows from related tables with explicit join conditions.
  6. 06Aggregations, grouping, and summariesSummarize rows with aggregate functions, GROUP BY, and HAVING.
  7. 07Subqueries, CTEs, and viewsBreak queries into understandable steps and reuse named query interfaces.
  8. 08Normalization and schema qualityReduce avoidable duplication and understand when denormalization is a deliberate trade-off.
  9. 09Transactions, ACID, and concurrent workGroup related changes into transactions and understand the guarantees they provide.
  10. 10Indexes, query plans, and performanceLearn what indexes trade off and use a query plan to guide optimization.
  11. 11Functions, procedures, and triggersCompare reusable database routines and automatic trigger behavior.
  12. 12NoSQL alternatives and scaling choicesCompare common non-relational models and choose storage around data and access patterns.
  13. 13Searchable SQL referenceSearch common PostgreSQL SQL statements, clauses, and database functions.

Documentation and further reading