The Mental Model That Changes Everything

Here's a secret that takes most engineers years to internalize: every computer system, from a simple script to a distributed architecture, does exactly three things.

Compute. Store. Network.

That's it. Once you see systems through this lens, everything clicks into place.

The Three Pillars

Compute

Processing data. Running logic. Executing instructions.

When your code adds two numbers, that's compute. When it sorts a list, that's compute. When it decides which branch of an if-statement to take, that's compute.

The CPU is the primary compute engine, but GPUs compute too. Even your network card does some computation.

Store

Keeping data somewhere.

This could be:

• Registers inside the CPU (tiny, blazing fast)
• RAM (bigger, still fast)
• Disk (huge, slower)
• A database on another machine

Anytime data persists, even for a microsecond, that's storage.

Network

Moving data between components.

Here's what surprises people: network doesn't just mean the internet. The wire connecting your keyboard to your motherboard? That's network. Data moving from RAM to CPU cache? Network. Your hard drive sending data to RAM? Network.

Any time data moves from point A to point B, that's the network pillar at work.

Tracing a Keystroke: From Keyboard to Screen

Let's trace what happens when you type a single character. This will make the three pillars concrete.

1. You press the "A" key
2. Network: The keystroke signal travels through the USB cable to your computer
3. Store: The keyboard controller stores the keycode temporarily
4. Network: The signal reaches the USB controller on your motherboard
5. Compute: The CPU processes an interrupt, recognizing a key was pressed
6. Store: The keycode is stored in a memory buffer
7. Compute: Your operating system figures out which application should receive this input
8. Network: The keycode is sent to your text editor's process
9. Compute: The text editor processes the character and updates its internal state
10. Store: The character "A" is stored in the document buffer
11. Compute: The text editor calculates what pixels need to change on screen
12. Network: Display data is sent to the GPU
13. Compute: The GPU renders the character
14. Network: The rendered frame is sent through the display cable
15. Store: The frame is stored in the monitor's buffer
16. You see "A" on screen

A single keystroke. All three pillars, multiple times.

Why This Matters

When something is slow or broken, it falls into one of three categories:

• Compute bottleneck: The CPU can't process fast enough
• Storage bottleneck: Reading or writing data is the slowdown
• Network bottleneck: Moving data between components is the constraint

Senior engineers instinctively ask: "Is this a compute problem, a storage problem, or a network problem?"

This mental model gives you that instinct.

A Simple Example: Adding Two Numbers

Consider the simplest program:

a = 5
b = 3
c = a + b
print(c)

Even here, all three pillars appear:

You cannot escape the three pillars. They are the foundation of everything.

Identifying Bottlenecks Before They Bite You

When you're designing a system or debugging a problem, ask yourself:

1. Where is the compute happening? Is it CPU-intensive? Could it benefit from caching results?
2. Where is data being stored? Is it in memory or on disk? Is the storage fast enough for the access patterns?
3. How is data moving? Are there unnecessary round trips? Is the network the bottleneck?

Most performance problems become obvious once you map them to these three pillars.

The Insight

Every system you will ever build or debug consists of compute, store, and network. Master this mental model, and you'll see through the complexity that confuses junior engineers.

Self-Check

Before moving on, make sure you can answer:

• What are the three pillars, and what does each one mean?
• When data moves from your SSD to RAM, which pillar is that?
• If your web app is slow, what three categories of problems should you investigate?