Making Online Learning Stick

The video made perfect sense yesterday, and the command is gone today. Making online learning stick means pausing to practice, writing down the decision behind a step, and revisiting it after the screen is closed.

Making Online Learning Stick Starts With a Question

Before starting a lesson, write one question you want it to answer. That gives the video a purpose. After a short segment, pause and predict the result of the next query or action. If the instructor changes an index, decide what plan change you expect before seeing it. Prediction turns a demonstration into an experiment.

I do not count minutes watched as skill gained. The useful measure is whether I can repeat the task without the video. Which step would you forget tomorrow? Pause there and do it yourself. A playback speed control cannot replace that small struggle.

Practice Beside the Video

Set up a disposable database or project before the lesson begins. Type the query, inspect the result, and alter one input. A copied script can run without being understood. Change a predicate, add a NULL row, or test a duplicate key to see where the concept stops working. Keep the environment safe to reset.

I leave the video paused until I can explain the output in a sentence. If I cannot, I return to the earlier step or documentation. That takes longer than watching straight through and saves time the next time the problem appears at work.

Write Notes About Decisions

A useful note says why a method was chosen, what it assumes, and how to check it. A transcript of every command is hard to review later. Save a compact example and one edge case. Label the SQL Server version and database context when they matter. Notes should help you reconstruct the reasoning without replaying the entire lesson.

For a query tuning lesson, I note which predicate was selective and which plan operator changed. I do not write “add index” as a universal rule. What condition would make the index a poor choice? That answer belongs in the note beside the example.

Revisit After a Gap for Making Online Learning Stick

Review the key idea after a day, then after a longer gap. Do not merely reread the note. Try to rebuild the example from memory and check the result. The difficulty of recalling the step is useful feedback. If it fails, repair the note and repeat the experiment. A small planned review is easier than relearning a whole course before a project.

I keep a short list of topics that need another pass. The list is not a judgment. It is a schedule. An error message that once seemed obvious can look unfamiliar after a month. Repetition makes the response faster when it matters.

Build One Small Thing

Use the concept in a finished artifact: a stored procedure with tests, a backup validation script, or a report with checked totals. A project forces decisions the lesson does not cover. It also reveals gaps between understanding one example and applying the idea to new data. Keep scope small enough to finish.

This query is a simple starting point for an order summary project. The project is not done when it runs. Check customers with no orders, canceled orders, and duplicate joins before presenting a total.

SELECT CustomerId, COUNT_BIG(*) AS orders_placed,
       SUM(OrderAmount) AS total_amount
FROM dbo.Orders
GROUP BY CustomerId;

Explain It to Another Person

Try a short explanation without the instructor’s words. Describe the problem, the rule, and the failure case. A teammate can ask a question that exposes a gap. If no teammate is available, write a paragraph for your future self. Clear explanation is a strong test of understanding.

I avoid pretending that every lesson has one universal answer. A query plan decision depends on data distribution and workload. State the conditions under which the example works. That keeps the explanation useful when someone tries it on a different server.

Keep a Checked Example for Making Online Learning Stick

Save a tiny fixture and a query whose result you can verify by hand. The example below finds customers with no order in the sample. It is useful for practicing NOT EXISTS and for seeing how a new order changes the answer. Add one order, rerun, and explain the difference.

I keep the fixture with the note. A screenshot of the final result fades quickly, while a runnable example can be challenged. Which assumption would you test next? Write it down before closing the lesson.

SELECT c.CustomerId, c.CustomerName
FROM dbo.Customer AS c
WHERE NOT EXISTS
(
    SELECT 1
    FROM dbo.Orders AS o
    WHERE o.CustomerId = c.CustomerId
);

Making online learning stick after a lesson means closing the video and reproducing the idea from memory on a small fixture. If you cannot explain why the result changed, return to the specific step rather than replaying the whole course. I use a three-part note: the claim, the script that tests it and the result I observed. That turns passive watching into a checked example.

Space the practice. Revisit the same concept after a few days with a slightly different input, such as a null, duplicate or larger table. The new case reveals whether you learned the rule or memorized one demonstration. Keep a record of mistakes without embarrassment; they are excellent future exercises. If the topic affects production, verify the behavior on the relevant SQL Server version in a safe environment. Completion badges are pleasant, but a reproducible explanation is more durable.

Share a short explanation with a teammate when possible. Teaching forces vague phrases like ‘the optimizer just knows’ into a testable statement. A good learning session ends with one thing you can now do and one question that still needs evidence.

Making online learning stick also means choosing a visible application of each lesson. After learning about isolation, write a two-session test. After learning about indexes, compare a query before and after an index on a disposable table. I keep the example small enough to rerun quickly. A lesson becomes durable when you can reproduce the behavior, explain the boundary and change one input without losing the thread.

Related reading on this blog: Trying New SQL Server Features Without Risk and Absolute Beginners 10 Queries.

Online learning is not completed by watching, it is retained by using and revisiting the idea.

Published by Pinal Dave on SQLAuthority. More of my work at pinaldave.com.