DEV Community

Yodit Weldegeorgise
Yodit Weldegeorgise

Posted on

Fail Fast, Fail Forward

For a long time, I thought failing meant I had done something wrong.
Over time, I realized it usually meant I waited too long to test an idea, ask a question, or try a different approach.

Fail fast, fail forward is not about celebrating failure.
It is about ๐ซ๐ž๐๐ฎ๐œ๐ข๐ง๐  ๐ญ๐ก๐ž ๐œ๐จ๐ฌ๐ญ ๐จ๐Ÿ ๐ฅ๐ž๐š๐ซ๐ง๐ข๐ง๐ .

What fail fast actually means

Fail fast means ๐ ๐ž๐ญ๐ญ๐ข๐ง๐  ๐Ÿ๐ž๐ž๐๐›๐š๐œ๐ค ๐ž๐š๐ซ๐ฅ๐ฒ.

Instead of spending weeks polishing something in isolation, you put it in front of reality as soon as possible. Reality can be code running, a question asked in a meeting, or trying a new approach even if you are not fully confident yet.

The goal is not speed for the sake of speed.
The goal is ๐œ๐ฅ๐š๐ซ๐ข๐ญ๐ฒ.

A technical example from data structures

This idea shows up very clearly in data structures.

In Java, HashMap is a good example of a ๐Ÿ๐š๐ข๐ฅ ๐Ÿ๐š๐ฌ๐ญ data structure.

When you iterate over a HashMap and modify it at the same time, Java throws an exception immediately. It does not try to recover or continue quietly. It stops execution so the problem is visible right away.

This behavior is intentional.

The goal is not to make the program crash randomly.
The goal is to ๐ฌ๐ฎ๐ซ๐Ÿ๐š๐œ๐ž ๐›๐ฎ๐ ๐ฌ ๐ž๐š๐ซ๐ฅ๐ฒ, while they are still easy to understand and fix.

Other data structures are designed to be ๐Ÿ๐š๐ข๐ฅ ๐ฌ๐š๐Ÿ๐ž.

For example, collections like CopyOnWriteArrayList work on a copy of the data. Modifications do not affect the current iteration, so the program continues running without throwing an error.

This feels safer, but it also means issues can go unnoticed longer.

Neither approach is wrong.
They solve different problems.

Fail fast structures prioritize ๐ž๐š๐ซ๐ฅ๐ฒ ๐Ÿ๐ž๐ž๐๐›๐š๐œ๐ค ๐š๐ง๐ ๐œ๐จ๐ซ๐ซ๐ž๐œ๐ญ๐ง๐ž๐ฌ๐ฌ.
Fail safe structures prioritize ๐ฌ๐ญ๐š๐›๐ข๐ฅ๐ข๐ญ๐ฒ ๐š๐ง๐ ๐œ๐จ๐ง๐ญ๐ข๐ง๐ฎ๐ข๐ญ๐ฒ.

Seeing this in code helped me understand the idea beyond theory.

A simple example from backend development

When I started building backend APIs, I would often overthink structure before even running the application. I wanted everything to be clean before seeing if it actually worked.

That usually backfired.

Now I run the application early, even if the code is incomplete. Errors show up quickly. Misunderstandings become obvious. I learn what the framework expects instead of guessing.

Failing fast here means I spend less time being stuck and more time ๐š๐๐ฃ๐ฎ๐ฌ๐ญ๐ข๐ง๐  ๐ข๐ง ๐ญ๐ก๐ž ๐ซ๐ข๐ ๐ก๐ญ ๐๐ข๐ซ๐ž๐œ๐ญ๐ข๐จ๐ง.

Applying this idea to public speaking

Public speaking did not become easier because I suddenly felt confident.
It became easier because I stopped waiting until I felt ready.

Early speeches were imperfect. Timing was off. Feedback was direct. None of that meant I was bad at speaking. It showed me what needed attention next.

Failing forward meant taking that feedback and applying ๐จ๐ง๐ž ๐ฌ๐ฆ๐š๐ฅ๐ฅ ๐ข๐ฆ๐ฉ๐ซ๐จ๐ฏ๐ž๐ฆ๐ž๐ง๐ญ ๐š๐ญ ๐š ๐ญ๐ข๐ฆ๐ž, instead of trying to fix everything at once.

Why failing forward matters more than failing fast

Failing fast gives you information.
Failing forward means ๐ฒ๐จ๐ฎ ๐ฎ๐ฌ๐ž ๐ข๐ญ.

Failing forward looks like:

Making ๐จ๐ง๐ž ๐š๐๐ฃ๐ฎ๐ฌ๐ญ๐ฆ๐ž๐ง๐ญ based on feedback

Asking a ๐œ๐ฅ๐ž๐š๐ซ๐ž๐ซ ๐ช๐ฎ๐ž๐ฌ๐ญ๐ข๐จ๐ง next time

Trying again with ๐ฌ๐ฅ๐ข๐ ๐ก๐ญ๐ฅ๐ฒ ๐›๐ž๐ญ๐ญ๐ž๐ซ ๐ฎ๐ง๐๐ž๐ซ๐ฌ๐ญ๐š๐ง๐๐ข๐ง๐ 

It is not dramatic. Most progress is ๐ข๐ง๐œ๐ซ๐ž๐ฆ๐ž๐ง๐ญ๐š๐ฅ ๐š๐ง๐ ๐ช๐ฎ๐ข๐ž๐ญ.

The model I follow

The model I follow is simple:

  1. Try early

  2. Observe what does not work

  3. Adjust one thing

  4. Try again

There is ๐ง๐จ ๐ฉ๐ž๐ซ๐Ÿ๐ž๐œ๐ญ ๐ญ๐ข๐ฆ๐ž ๐ญ๐จ ๐ฌ๐ญ๐š๐ซ๐ญ.
There is ๐ง๐จ ๐›๐ž๐ง๐ž๐Ÿ๐ข๐ญ ๐ข๐ง ๐ฐ๐š๐ข๐ญ๐ข๐ง๐ 

This is the same approach I use in tech, learning, and preparing workshops.

What I'm working on next

I am excited to share that I will be giving a workshop titled:

๐€ ๐๐ž๐ ๐ข๐ง๐ง๐ž๐ซ-๐…๐ซ๐ข๐ž๐ง๐๐ฅ๐ฒ ๐–๐จ๐ซ๐ค๐ฌ๐ก๐จ๐ฉ: ๐‡๐จ๐ฐ ๐ญ๐จ ๐’๐ฉ๐ž๐š๐ค ๐‚๐จ๐ฆ๐Ÿ๐จ๐ซ๐ญ๐š๐›๐ฅ๐ฒ ๐ข๐ง ๐๐ฎ๐›๐ฅ๐ข๐œ

The ideas around failing fast and failing forward are a core part of how I approach public speaking, especially for beginners who feel pressure to be confident before they start.

I will write more about the process, lessons, and practical exercises from this workshop in future blog posts.

Top comments (2)

Collapse
 
bhavin-allinonetools profile image
Bhavin Sheth

This really resonates.
โ€œFail fastโ€ finally clicked for me once I saw it as getting feedback early, not rushing or being reckless.

I also like how you tied it to real examples (HashMap vs fail-safe collections, running APIs early). That framing makes the idea practical, not motivational fluff.

Quiet, incremental progress is such an underrated truth โ€” thanks for putting it into words.

Collapse
 
yoditdevn8n profile image
Yodit Weldegeorgise

Thank you so much for sharing your perspective. Iโ€™m glad you found it helpful.