How to Learn Anything in Half the Time Using the Feynman Technique

How to Learn Anything in Half the Time Using the Feynman Technique

There's a difference between understanding something and thinking you understand it.

I realized this gap the hard way during a code review early in my career. I'd been using async/await for months and felt confident with it. Then a senior developer asked me a simple question: "Can you explain why we need await here? What's actually happening under the hood?"

I fumbled. I used words like "it just resolves the promise" and "it makes it synchronous" — both of which are imprecise or wrong. I understood async/await well enough to use it. I didn't understand it well enough to explain it.

That's the gap the Feynman Technique targets. It's named after Nobel Prize-winning physicist Richard Feynman, who believed that you don't truly understand something until you can explain it simply. He applied this relentlessly throughout his career — not just for teaching, but as his own learning method.

The technique works for programming, machine learning, system design, data structures, cloud architecture, or any technical domain. Let me show you exactly how to apply it.

The 4-Step Feynman Technique Process

The cycle repeats until your explanation is clear, simple, and complete — with no unexplained terms.

Why It Works: The Science Behind It

The Feynman Technique works because of several well-documented learning principles.

The Generation Effect: Research consistently shows that generating information from memory produces stronger retention than re-reading or re-watching the same material. When you write out an explanation of recursion from scratch, your brain encodes the information differently than when you passively watch a tutorial about it.

Desirable Difficulty: Learning feels easier when you're recognizing familiar material (re-reading your notes) than when you're generating explanations from memory. The uncomfortable feeling of struggling to explain something is a sign that real learning is happening — not a sign that you need easier material.

The Illusion of Knowing: Passive learning creates the feeling of understanding without the substance. Reading a chapter about hash maps feels like understanding hash maps. Writing an explanation of hash maps from memory reveals whether you actually do. The Feynman Technique shatters the illusion before it causes problems.

I've tested this on myself repeatedly. Every time I thought I understood a concept and then tried to explain it simply, I found gaps. Every time I found those gaps and filled them, I retained the corrected understanding far better than any re-reading had ever produced.

Applying the Feynman Technique to Programming Concepts

Example 1: Recursion

Step 1 — Choose the concept: Recursion

Step 2 — Teach it simply: "Recursion is when a function calls itself. You give it a problem, and instead of solving the whole thing, it solves a small piece and then calls itself to solve the rest — until the problem is small enough to solve directly."

Step 3 — Identify the gaps: This explanation is okay, but it doesn't address: Why doesn't it loop forever? What stops it? What happens in memory when a function calls itself? Why is this better than a regular loop for some problems?

Step 4 — Refine: "Recursion is when a function solves a problem by breaking it into a smaller version of the same problem. It keeps calling itself with smaller and smaller inputs until it hits a base case — a condition where the answer is simple enough to return directly without another call. Each call is added to the call stack (a memory structure that tracks what needs to run). When the base case is reached, the stack unwinds, returning results back up the chain. You use recursion when a problem naturally breaks into smaller identical subproblems — like traversing a file system where each folder contains more folders."

That second explanation demonstrates real understanding. The first one would fall apart under any follow-up question.

Example 2: Database Indexing

Initial explanation attempt: "Indexes make queries faster. You add an index to a column and searches on that column speed up."

Gaps revealed: Why do indexes make it faster? What's the tradeoff? Why not index every column? What happens during a write with an index? What structure does the index use?

Refined explanation: "A database index is a separate data structure (usually a B-tree) that stores the values of a column alongside pointers to the corresponding rows — sorted and organized for fast lookup. Without an index, finding rows matching WHERE email = 'user@example.com' requires scanning every row (O(n)). With an index on email, the database navigates the B-tree to find the value in O(log n) time — dramatically faster for large tables. The tradeoff: indexes consume disk space and slow down INSERT/UPDATE/DELETE operations because the index must be updated every time the indexed column changes. Index everything you query often; avoid indexing columns you write to constantly without reading."

Learning Techniques Comparison

The Feynman Technique and spaced repetition complement each other well: Feynman builds genuine understanding, spaced repetition maintains retention over time. Combine them for durable technical knowledge.

The Rubber Duck Method: Feynman's Cousin

You may have heard of "rubber duck debugging" — explaining your code to an inanimate object forces you to articulate what each line does, which often reveals the bug. This is essentially the Feynman Technique applied to debugging.

The same principle applies to learning. When you explain a concept out loud to a rubber duck, a stuffed animal, or even to yourself in a mirror, you're forcing the verbalization that reveals gaps. The discomfort of saying "and then it... does the thing" is the exact signal that you need to go back and understand "the thing" properly.

I keep a notebook where I write Feynman-style explanations when I'm learning new material. When I can fill a page with a clear, jargon-free explanation of a concept, I consider it understood. When my explanation has gaps or placeholder words, I mark those for deeper research.

Applying the Feynman Technique to System Design

System design is an area where surface familiarity is especially dangerous — it's easy to know the terms (load balancer, caching, CDN, message queue) without understanding when to use them and why.

Apply the technique to individual components:

Concept: Load Balancer

Initial explanation: "Distributes traffic across multiple servers so one server doesn't get overwhelmed."

Gaps: What are the different balancing algorithms? What's the difference between L4 and L7 load balancers? What happens to sessions when traffic is distributed? How does health checking work?

Refined explanation gets into consistent hashing, sticky sessions, health checks, and the difference between application-layer routing (L7) and transport-layer routing (L4). Each gap you fill strengthens your understanding of the full picture.

For system design interview prep specifically, this method is far more effective than memorizing architecture diagrams. When you understand each component well enough to explain it, you can reason about new combinations rather than just pattern-matching to remembered examples.

A 4-Week Implementation Plan

Week 1: Apply the technique to 3 concepts from your current work or study. Don't worry about perfection — the goal is to surface gaps.

Week 2: Choose concepts specifically where you feel uncertain. The discomfort zone is where the technique delivers the most value.

Week 3: Apply it to concepts you think you know well. You'll find gaps in familiar material too — this builds genuinely solid foundations.

Week 4: Try explaining concepts to an actual person (colleague, study partner, community forum). Teaching a real audience adds stakes that sharpen the quality of your explanations.

The habit compounds. After a month of this practice, you'll notice a shift: you'll start catching your own shallow understanding in real-time, before it causes problems in your work.

Feynman Applied to Tech Certifications

Certification exams test understanding, not just memory. The Feynman Technique is particularly effective for certification study because it reveals which exam domains you actually understand versus which ones you've passively reviewed.

For our AWS Solutions Architect study guide, we recommend applying the Feynman Technique to each AWS service you encounter: explain what the service does, why you'd use it instead of alternatives, what its limitations are, and what happens when it fails. This produces deeper exam readiness than flashcard drilling alone.

Conclusion

The Feynman Technique isn't magic — it's structured honesty about what you know. The reason it accelerates learning is that it stops you from spending time re-learning things you've already learned while revealing the specific things you haven't truly learned yet.

Every hour spent doing the Feynman Technique replaces multiple hours of passive re-reading that would create the illusion of learning without the substance. The technique is uncomfortable because the gaps are uncomfortable. But identifying a gap is the first step to filling it — and you can't fill gaps you don't know exist.

Start with one concept today. Write down your explanation. See where it breaks down. That breakdown is your next learning target.

For more strategies on building lasting learning habits, read our guide on how to build a learning habit as a developer. And for curated resources to deepen your understanding across tech topics, explore our learning resources category.

Frequently Asked Questions

What is the Feynman Technique in simple terms?

Pick a concept, explain it in plain language as if teaching someone with no background in the topic, identify where your explanation breaks down or uses unexplained terms, and use those gaps to guide further study. Repeat until your explanation is clear and complete.

How does the Feynman Technique work for programming concepts?

Apply it to any programming concept by writing a plain-language explanation. Where your explanation says "it just works" or relies on unexplained jargon, that's a gap. Fill those gaps through documentation or deeper reading, then rewrite your explanation without jargon.

How long does the Feynman Technique take?

A single cycle takes 30–90 minutes for medium-complexity topics. The time investment is front-loaded, but retention is 2–3x higher than passive review, making total learning time shorter despite more intense initial effort.

What is the difference between the Feynman Technique and regular note-taking?

Note-taking is passive and can create an illusion of understanding. The Feynman Technique requires generating explanations from memory, which reveals actual gaps rather than hiding them under comprehensive notes.

Can I use the Feynman Technique for exam preparation?

Yes — apply it to each exam domain after studying, then use the gaps it reveals to guide your final study focus. This approach identifies weak areas more accurately than re-reading notes, which often produces false confidence before exams.