# Where to Go Next

A look back at what you can now do with design patterns, a last task that finds patterns in code you already use, and how to keep the patterns, and your own, working for you.

Novice · Software Development · OOP · Updated November 17, 2026

By Gregor Dzierzon

## Key takeaways

- You can now solve a design problem nobody has named for you, by reading its smell, trying the plain fixes, and picking the one that holds up.
- Every pattern is a well-known answer to a common problem, with a cost; knowing when to leave one out is part of knowing it.
- Your pattern cards are your own catalog, and your team's repeated solutions are patterns too, once they're written down.

This is the last lesson of the course. When you started, "a pattern" might have meant a diagram to memorize. Now it means a problem you recognize, a few plain fixes you'd try first, and a well-known answer with a known cost. This lesson is for the moment you finish and ask "now what?": it looks back at what you can do, gives you one last task, and shows how to keep the patterns working for you.

## What you can do now

Here's the course, as things you can do:

- **Read and sketch a design:** class and object diagrams, role diagrams with their fence around what changes, and the ideas behind every pattern, SOLID included (Module 1).
- **Take a small app through its first change requests** without a rewrite: one place that says `new`, a deal handed in as a function, listeners told about each order, one simple front for checkout (Module 2).
- **Grow an app** with statuses, routes, carriers, shipments with many parts, and an undo button, and draw its sequence and state diagrams (Module 3).
- **Connect an app to systems you don't control:** make odd APIs fit, wrap a slow service with a cache and a stand-in, keep working when it's down, and let devices talk through a hub (Module 4).
- **Find the patterns a framework is built from:** dependency injection, repositories, MVC and middleware (Module 5).
- **Solve the rarer problems:** rules your users write, and things too many or too expensive to make one at a time (Module 6).
- **Rescue old code:** read its smells as symptom, cause and cure, change it safely under tests, take out patterns that don't earn their keep, and name your team's own patterns (Module 7).

Most of all, you can face a problem nobody has named for you: read the smell, try the plain fixes, see where they break, and pick the one that holds up, including "no pattern at all". Anything you can't do yet is a next step, not a wall.

## A last task: find the patterns in code you use

Pick a library or framework you use (the web framework from Module 5, your test library, anything with its source online). Then:

1. **Find three patterns in it.** Look for the shapes you know: a chain of middleware, an event you subscribe to, a builder with named steps, a factory that picks a class from a name.
2. **For each, name the problem it solves there,** in one sentence, before you name the pattern.
3. **For one of them, write its pattern card** in the course's shape, including *Skip it when*.

There's no answer key, because every library is different. If you can say the problem before the name for each one, you've done the task right.

## Keep it working for you

- **Your pattern cards are your catalog.** Every pattern lesson's cheat sheet is its card, in the same shape. Keep them where you'll look, and add cards for your own team's patterns as you find them (*Writing a Pattern Card Your Team Will Read*).
- **Practice the names.** Each lesson's key terms open in flash cards, Memory and Match It, where the scenarios describe a problem and you pick the fix.
- **Watch for the third copy.** The next time you're about to paste a solution for the third time, that's a pattern of your own asking for a name (*When Repetition Becomes a Pattern: The Rule of Three*).

## So what

Design patterns aren't a list to memorize; they're what teams learned by solving the same problems again and again. You've now solved those problems yourself, so the names are yours to use, and the next pattern you find may be one you name.

## Key terms

- [Design Pattern](https://www.ask-codey.com/glossary/design-pattern)
- [Code Smell](https://www.ask-codey.com/glossary/code-smell)
- [Rule of Three](https://www.ask-codey.com/glossary/rule-of-three)

## Related

- [When Repetition Becomes a Pattern: The Rule of Three](https://www.ask-codey.com/lessons/dp-rule-of-three)
- [Writing a Pattern Card Your Team Will Read](https://www.ask-codey.com/lessons/dp-writing-a-pattern-card)
- [A Team Pattern Catalog: Adding, Changing and Retiring](https://www.ask-codey.com/lessons/dp-team-pattern-catalog)
- [Patterns in Code Reviews and Interviews](https://www.ask-codey.com/lessons/dp-patterns-in-reviews-and-interviews)

Source: https://www.ask-codey.com/lessons/dp-where-to-go-next
