# Where to Go Next

A look back at what you can now do with data structures and Big-O, a last task, spotting the structures inside three apps you use, and how to choose what to learn next.

Novice · Data Structures · Updated November 17, 2026

By Gregor Dzierzon

## Key takeaways

- You can now explain Big-O in plain words, and build, choose and justify the classic data structures and algorithms in your language.
- The skill that matters most is choosing a structure for a job and saying why: what its main operations cost.
- Every app you use is built from the structures in this course, and you can now spot them from what the app does most.
- Good next steps are design patterns, more of your own language, and practice problems solved out loud.

This is the last lesson of the course. When you started, "O(n²)" was a strange symbol and a hash table was a black box inside your language. 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 helps you pick what to learn next.

## What you can do now

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

- **Predict how code slows down** as its data grows, read Big-O aloud, and prove it with a stopwatch (Module 1).
- **Build and use the structures in a line:** arrays, growing arrays, linked lists, stacks and queues, and say what each operation costs (Module 2).
- **Write recursive solutions** and trace them on the call stack (Module 3).
- **Search and sort**, from reading every item to binary search, merge sort and quicksort, and use your language's sort correctly (Module 4).
- **Look things up instantly** with hash tables, sets and dictionaries, including keys made from your own objects (Module 5).
- **Build trees, heaps and tries** for org charts, emergency rooms and word suggestions (Module 6).
- **Work with graphs**: find how many steps apart two things are, who can reach whom, the fastest route and an order that keeps every prerequisite first (Module 7).
- **Choose on your own:** take a problem nobody has solved for you, find the job it does most, and choose the structure, out loud, with its Big-O, as you did for the five tickets of *Exercise: Pick the Structure* (Module 7).

That's what college data structures classes cover, and what technical interviews ask about. Anything you can't do yet is a next step, not a wall.

## A last task: spot the structures

Pick three apps you use every week: a music app, a map, a chat app, a game, a shopping site, anything. For each one:

1. **Name two things the app does all the time,** such as "shows the next song" or "says whether a username is taken".
2. **For each, say which structure you'd choose,** and the Big-O that makes it fast.
3. **Name one plain try that would break,** and at what size.

There's no way to look inside most apps, so there's no answer key. If you can say why for each choice, you've done the task right. Here's one worked through, so you can see the shape.

&lt;details>
&lt;summary>One app, worked through: a music app&lt;/summary>

- **"Play next" and the queue of songs coming up:** a queue, or a linked list when songs can be dropped in anywhere, because adding and taking from the front are O(1). A plain array would slide every song along each time one is taken from the front.
- **Search as you type:** a trie, or a sorted list with binary search, because every keystroke asks for "every title starting with these letters". Reading all 100 million titles per keystroke would be O(n) each time.
- **"Recently played", no repeats, newest first:** a dictionary together with a linked list, as in the photo app in *New Problems, Your Choice*, because a replayed song jumps to the front in O(1).
- **"Fans also like":** a graph of artists, searched a step or two out from the one you're playing.

&lt;/details>

## Choosing your next step

There's no wrong order. Choose by what you want to do next:

| If you want to... | Next |
|---|---|
| Build full web apps in the language you used here | *C# Full-Stack Bootcamp*, *Java Full-Stack Bootcamp* or *JavaScript in Depth* on ask-codey.com |
| Get ready for technical interviews | Practice problems, worked out loud, as in *Your Turn at the Whiteboard: Solving a Problem Out Loud* |
| Keep the ideas fresh | Come back to the cost cards in *The Feature Is Slow: Which Structure Fixes It?* whenever a feature feels slow |

For interview practice, pick one problem a day. Clarify it, say a plan and its Big-O before you code, and test it with its edge cases. A problem you can explain is a problem you've learned.

## So what

You can now look at code and see how it will grow, choose the structure that keeps it fast, and explain why, including for problems nobody has shown you. That's the foundation the rest of your programming is built on.

## Key terms

- [Big-O Notation](https://www.ask-codey.com/glossary/big-o-notation)
- [Algorithm](https://www.ask-codey.com/glossary/algorithm)
- [Data Structure](https://www.ask-codey.com/glossary/data-structure)

## Related

- [The Feature Is Slow: Which Structure Fixes It?](https://www.ask-codey.com/lessons/ds-choosing-a-structure)
- [Your Turn at the Whiteboard: Solving a Problem Out Loud](https://www.ask-codey.com/lessons/ds-solving-out-loud)
- [What You Can Build with Data Structures](https://www.ask-codey.com/lessons/ds-what-you-can-build)

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