Databases

51 courses, 865 lessons. A real Kali Linux lab in the browser.

Database concepts: why, how and which one (Level 101, 15 lessons): Through examples you learn why data lives in databases rather than files, how relational, document and key-value models differ and how to choose the right engine for a job.
SQL fundamentals (MySQL) (Level 101, 21 lessons): Tables, queries, joins and user privileges.
SQL query practice (Level 101, 16 lessons): You solve short query tasks on ready-made datasets such as a library, a shop and a clinic, combining what you learned into one report at the end of each section.
PostgreSQL quick start (Level 101, 15 lessons): Starting from zero, you connect with psql, create your first database and tables, insert and query data and add users to learn how PostgreSQL works.
SQLite fundamentals (Level 101, 17 lessons): You will learn from scratch to create and query SQLite, the single-file database found in phones, browsers and apps.
MongoDB (Level 101, 18 lessons): Documents, collections, queries and access control.
Redis (Level 101, 16 lessons): Key-value storage, data types, caching and configuration.
Data modelling and schema design (Level 201, 18 lessons): You derive entities and relationships from a business’s needs, draw an ER diagram, remove duplication and inconsistency through normalisation and let constraints enforce correctness in the database.
Intermediate SQL: joins, subqueries and set operations (Level 201, 19 lessons): You answer real business questions in a single query using every kind of join, correlated subqueries, EXISTS, set operations and conditional expressions.
MySQL administration: installation, configuration, monitoring (Level 201, 19 lessons): You install a MySQL server, manage its configuration files and logs, set up users and storage engines and automate routine maintenance.
PostgreSQL (Level 201, 18 lessons): psql, schemas, roles, indexes and backups.
Advanced SQLite: durability, search and encryption (Level 201, 16 lessons): You will learn SQLite concurrency, full-text search, JSON, encryption and forensic inspection of application databases.
MongoDB data modelling (Level 201, 18 lessons): Starting from the application’s access patterns, you decide between embedding and referencing and design flexible yet orderly collections with schema validation and versioning.
MongoDB administration (Level 201, 16 lessons): You configure mongod, manage users and roles, and run a MongoDB server day to day with the import and export tools, logs and basic monitoring.
Application patterns with Redis (Level 201, 16 lessons): You use Redis in Python applications as a cache, session store, counter, queue and leaderboard, and learn each pattern’s pitfalls and proper key design.
Database project: a library system (Level 201, 15 lessons): You design and build a library’s lending system yourself end to end: from requirements to schema, from data to queries, from privileges to backups.
Analytical SQL: window functions and reporting (Level 301, 19 lessons): With window functions, recursive CTEs, grouping sets and pivots you produce analysis reports in SQL such as rankings, moving averages, cohorts and funnels.
Transactions and concurrency (Level 301, 18 lessons): Opening two sessions side by side, you watch ACID properties, the anomalies each isolation level allows, locks, MVCC and deadlocks live in PostgreSQL and MySQL.
SQL puzzles and challenges (Level 301, 16 lessons): You solve tough data questions taken from real work with a single SQL query and test your solution for correctness and speed.
Advanced MySQL: performance, replication and security (Level 301, 27 lessons): You will write fast MySQL queries, back up and replicate data, and configure the server securely.
MySQL backup and recovery (Level 301, 15 lessons): You protect MySQL data with mysqldump, mydumper and physical backups, recover to a point in time with the binlog, measure restore times and test backups regularly.
PostgreSQL administration (Level 301, 19 lessons): You install and configure a PostgreSQL cluster, manage roles, connections, extensions, logs and statistics views, and upgrade versions safely.
PostgreSQL backup and recovery (Level 301, 15 lessons): You set up PostgreSQL backups with pg_dump formats, pg_basebackup, WAL archiving and pgBackRest, recover to a point in time and prove restores with regular drills.
Server-side programming in PostgreSQL: PL/pgSQL (Level 301, 17 lessons): You write functions, procedures and triggers in PL/pgSQL and learn error handling, safe use of dynamic SQL and testing database code with pgTAP.
Advanced PostgreSQL: performance, replication and security (Level 301, 27 lessons): You will learn PostgreSQL rich data types, fast queries, backup and replication, and row-level security.
SQLite in applications (Level 301, 16 lessons): You use SQLite in Python and Node.js applications with a proper connection, transaction, migration, concurrency and testing setup, and run it safely in production.
Advanced MongoDB: aggregation, replication and security (Level 301, 23 lessons): You will learn MongoDB reporting queries, index and schema patterns, replica sets, access control and encryption.
MongoDB aggregation pipeline in depth (Level 301, 17 lessons): Using the stages and expression operators of the aggregation pipeline in depth, you produce reports, window calculations, time series analyses and data transformations.
Advanced Redis: streams, replication and security (Level 301, 22 lessons): You will build queue, ranking and approximate-counting patterns in Redis and learn to monitor and configure it securely.
Database backup strategy and disaster recovery (Level 301, 16 lessons): You derive a backup plan for different engines from recovery targets, automate and encrypt backups, keep remote copies and prove disaster recovery through drills.
Database monitoring and observability (Level 301, 15 lessons): You collect connection, query, lock, replication and disk metrics into dashboards, write meaningful alert rules and trace a problem from metrics down to logs.
Schema migrations and zero-downtime change (Level 301, 15 lessons): You version schemas with migration tools, change columns and indexes on large tables without holding long locks, and carry out data backfills and rollback plans.
Database troubleshooting challenges (Level 301, 15 lessons): In real failure scenarios such as a full disk, lock queues, replication lag and a broken backup, you find the cause, fix it and write a short incident report.
SQL query optimisation (Level 401, 18 lessons): You read execution plans, understand how B-tree indexes work, the join algorithms and statistics, and speed up slow queries by measuring.
MySQL replication and high availability (Level 401, 17 lessons): You set up GTID-based, semi-synchronous and group replication, route traffic with MySQL Router and ProxySQL, and rehearse failover and failback.
MySQL performance tuning (Level 401, 17 lessons): You find bottlenecks with performance_schema and the sys schema, tune InnoDB memory and disk settings for the workload and measure before and after with sysbench.
PostgreSQL performance tuning (Level 401, 18 lessons): You measure bottlenecks with pg_stat_statements, auto_explain and pgbench, tune memory, checkpoint, autovacuum and parallel query settings for the workload and improve plans.
PostgreSQL replication and high availability (Level 401, 16 lessons): You set up streaming and logical replication, manage synchronous replicas, replication slots and lag, and run automatic failover and drills with Patroni.
The SQLite file format and data recovery (Level 401, 15 lessons): You examine the SQLite file header, pages, B-trees, freelist and WAL file at hex level and recover deleted records and corrupted files.
MongoDB replica sets and sharding (Level 401, 17 lessons): You build a replica set and manage elections, read preferences and failover, then build a sharded cluster, choose a shard key and apply balancing and resharding.
MongoDB performance tuning (Level 401, 15 lessons): You find slow operations with the profiler, explain and server metrics and speed MongoDB up for the workload with index, query, schema and WiredTiger cache tuning.
Redis high availability and Redis Cluster (Level 401, 17 lessons): You set up replication and Sentinel failover in depth, configure and reshard Redis Cluster, and manage persistence and backups across the cluster.
Database security: authorisation, encryption, backup and auditing (Level 401, 18 lessons): You will build a shared security framework for MySQL, PostgreSQL, MongoDB and Redis, protecting data with authorisation, encryption, backups and auditing.
Inside a database engine: storage, indexes and logs (Level 501, 15 lessons): You understand database internals by studying pages, the buffer pool, B+trees, write-ahead logging and MVCC and writing a small key-value store in Python.
MySQL internals and advanced troubleshooting (Level 501, 14 lessons): You study InnoDB’s pages, redo, undo and lock structures and solve crash recovery, corruption, deadlock and memory problems in real failure scenarios.
PostgreSQL internals and extension development (Level 501, 13 lessons): You inspect heap pages, tuple headers, MVCC visibility, WAL records and the planner with tools, and write a small extension in C to understand PostgreSQL from the inside.
Extending SQLite: extensions and virtual tables (Level 501, 14 lessons): You write custom functions, aggregates, virtual tables and loadable extensions in C and Python, and apply R*Tree, the session extension and settings for embedded use.
MongoDB internals and advanced operations (Level 501, 13 lessons): You study the WiredTiger storage engine, the oplog, the replication protocol and chunk migration, then diagnose and recover MongoDB clusters in real failure scenarios.
Redis internals and performance (Level 501, 14 lessons): You study Redis data structure encodings, the event loop, the memory allocator and persistence internals, measure and fix latency and memory problems, and write server-side logic with Redis Functions.
Database hardening and security audit practice (Level 501, 15 lessons): You audit four engines against a security benchmark, collect findings automatically with scripts, set up key rotation and audit trails, and test the defences with attack simulations in your own environment.
Designing highly available data architectures (Level 501, 14 lessons): You compare consistency and availability trade-offs, replication topologies, consensus algorithms and disaster recovery, and test your design with fault injection.

Projects

Your first database: clinic appointment records: You move the appointments Lavinya Klinikleri keeps in a notebook into patient, doctor and appointment tables in MySQL. You load sample data and deliver the queries that answer eight front-desk questions (today’s appointments, the busiest doctor and so on).
From spreadsheet to SQLite: a workshop stock register: You take the stock list Karaçam Mobilya keeps in a spreadsheet as CSV and import it into a SQLite database. You write queries for materials running low and totals per supplier, and export the result as a report file the workshop lead can read.
Consistent records with transactions: You use transactions so linked records are saved all together or not at all, and show the data stays consistent when an operation is cut off halfway.
Run a bulk update safely and verify it: You update thousands of records at once by taking a backup first, applying the change in small steps, and verifying the result with counts.
End-of-day reporting across time zones: You combine end-of-day sales from branches in different countries into one report, handling time-zone differences correctly.
Searching flexible fields (JSON and MongoDB queries): You search data where every record has different fields, using JSON and MongoDB queries, and show the right records are found.
Add a feature to the schema (migration): You add tables and columns for a new feature to a running database with a reversible migration, showing the old data is unharmed.
Clean data and enforce it with constraints: You clean out duplicate and faulty records, then add database constraints so the same mistakes can no longer be entered.
Daily reconciliation: match two sources: You match the daily records from two separate systems, list the ones that do not agree, and present a report explaining the differences.
Keep a cache fresh (TTL and invalidation): You keep cached data from going stale using expiry times (TTL) and invalidation, and show users always see up-to-date information.
Limit database access to least privilege: You narrow database account permissions so each application can only do what it needs, and check that no excess access remains.
Prepare a MySQL server for a new application: You get a MySQL server ready for the new order application of Ayçiçeği Gıda: the configuration file, character set, application and reporting accounts, the slow query log and basic monitoring queries. You write a handover checklist showing the settings still hold after a restart.
Deploy an application with several databases: You deploy several data services for one application, such as a relational database, a document store and a cache, and show it works end to end.
Ranking with window functions: You rank sales or performance data within groups using window functions and deliver a query listing the top records of each group.
Speed up a slow query with an index: You examine a slow query, add a suitable index, and show the drop in query time with before-and-after measurements.
Prove a backup can be restored: You restore a database backup into a separate environment and prove with record counts and sample queries that the backup really works.
Prevent double booking with locks: You use locks to stop the same seat or room being sold to two people, and test with simultaneous requests that it no longer happens.
A sales summary with the MongoDB aggregation pipeline: From the store sales documents of Turnalı Perakende you produce the summaries that feed the management dashboard with the MongoDB aggregation pipeline: revenue by store and category, the weekly trend, the best-selling products. You add the index that speeds the pipeline up and check the results against a hand-calculated sample.
Recover deleted data by returning to a point in time (PostgreSQL): A table in the test database of Yelkovan Bankası has been emptied by mistake. Using continuous archiving and a base backup you restore the database to the moment just before the deletion (PITR), and document how many minutes of data were lost and how long recovery took.
A database monitoring dashboard with alerts: You install metric exporters for the PostgreSQL and MySQL servers of Kuzeyyıldızı Kargo and build a dashboard showing connection count, slow queries, disk usage and replication lag. With a load test you show the alert fires as the connection limit is approached.
A failover drill on a PostgreSQL cluster: You build a three-node PostgreSQL cluster with automatic failover for the meter data of Demirsu Enerji. You stop the primary, measure for how many seconds the application cannot write and whether any data is lost, rejoin the old primary, and write the drill report.
Measure, tune and report on a MySQL workload: The shipment database of Mavikaya Lojistik slows down at peak hours. You take a baseline with a load test, find the most expensive queries and the server settings that fall short, fix them, and write a performance report showing the effect of each change separately.
Recover records from a damaged SQLite file: The SQLite database of the case tracking application of Sedirli Hukuk Bürosu will not open after an interrupted write. Working on a copy, you examine the page structure and the journal file, move the readable records into a new database, and report what was recovered and what was lost.
A security audit and hardening for four databases: You audit the PostgreSQL, MySQL, MongoDB and Redis servers of Mercanköşk Otelcilik against a security baseline: authentication, permissions, network access, encryption, backups and audit logging. You rank the findings by severity, fix them, and deliver a report showing a re-audit closes them.