Pursuing the Unknown: How to Build a Structured & Repeatable Learning Model

This coming January will mark the 25th anniversary of me obtaining my first Cisco Certified Internetwork Expert (CCIE) in Routing and Switching (now known as Enterprise Infrastructure). Over the course of my career, I’ve seen lots of new technologies and solutions come and go, but one thing has always remained the same: change.

The IT industry is constantly changing. To remain relevant, you always need to be learning and expanding your knowledge base. In my case, this meant learning new topics deeply enough that I could turn around and explain them more plainly to students in my courses—from Enterprise Switching, to Service Provider Routing, to Data Center Fabrics. 

Learning a lot of these new technologies looked like an insurmountable task when I knew very little about them. By the end of my learning process, though, I would often find myself looking back and realizing that the technology wasn't necessarily more difficult than anything else I've learned throughout my career. Instead, it was simply unfamiliar. 

Over time, I realized I was approaching each new technology in roughly the same way. What started as an informal process eventually developed into a repeatable learning model that I still use today.

How Do You Eat an Elephant?

There’s an old saying that there is only one way to eat an elephant: one bite at a time. Learning works the same way. 

Rather than overwhelming myself by reading an entire book end to end, or trying to understand every detail of a new technology all at once, I take a small, modular approach, where each step builds on the one before it. The core of this learning model is a four-step process:

1. Start by understanding why the technology exists
2. Build something simple 
3. Go back and learn the deeper details
4. Return to the lab and explore the advanced implementation

The end result is a repeatable system for approaching subjects that initially seem overwhelming.

Step 1: Understand Why the Technology Exists

The first step is to get a basic understanding of the technology. At this point, I’m not trying to learn how it’s implemented. I’m trying to understand why it exists.

What problems was this technology designed to solve? What limitations existed in previous solutions? Why is this a better or different approach?

For example, when learning how modern Data Center Fabrics work, I needed to understand why there were limitations in Classical Ethernet Switching. Why did Spanning Tree Protocol (STP) result in active/standby forwarding instead of active/active? It’s because of the inherent problems that Layer 2 bridging loops can create. Once I understood those limitations, I had context for why newer Data Center architectures evolved the way they did.

Before I start worrying about all the configuration details, I want to understand the problem we’re trying to solve.

Step 2: Build the Simplest Working Implementation

The second step is to get a basic hands-on understanding of how the technology works.

This is where I start experimenting with lab scenarios, looking at the most basic functionality of the technology without any of the advanced features or bells and whistles. I want to know the minimum configuration required to get the technology functional.

Along with learning this basic implementation, I want to learn how to verify that it’s actually working the way it’s supposed to. For a network device, this might mean learning the relevant show commands, debug commands, packet captures, or other forms of verification.

For Data Center Fabrics, this meant learning how to build a basic VXLAN Flood-and-Learn network before jumping into BGP EVPN. Once I saw this config functioning, it made more sense what the scaling limitations of this design were, and why using BGP for the VXLAN control-plane would be a better solution.

By the time I complete the first two steps, I have a basic understanding of the purpose of the technology, the problems it’s designed to solve compared to previous solutions, and how I can implement and verify a basic version of it in a live environment. That foundation makes the next step much easier.

Step 3: Go Back and Learn the Details

Now I go back through the learning process again, but at a much deeper level. This is where I spend more time reading detailed documentation, watching technical presentations, referencing RFCs, and studying how advanced implementations of the technology work.

In the case of Data Center Fabrics, this meant moving beyond the basic operation of a single fabric and studying how multi-site designs work, and how to connect multiple data centers over a Data Center Interconnect.

The important difference is that I’m no longer reading the material without context. I already understand the basic problem. I’ve already configured the technology, seen it work, and know some of the basic terminology and verification commands.

Now I have the foundation I need to build that advanced understanding. Instead of trying to absorb hundreds of pages of documentation at the beginning, I can connect each new detail to something I already understand.

Step 4: Learn the Advanced Implementation

The final step is to return to the hands-on implementation and start exploring the advanced functionality. This is where I want to understand all the different "nerd knobs" I can control when configuring the technology. More importantly, I want to understand why those options exist and what problems they’re designed to solve.

For a Data Center Fabric, this could mean understanding how ARP suppression works, or how BUM traffic—Broadcast, Unknown Unicast, and Multicast—needs to be handled differently across a routed fabric as opposed to a classical Ethernet network (where a true broadcast domain natively exists).

At this point, the goal isn’t to simply know which commands enable a feature. I want to understand exactly what changes when I enable it, why that behavior is desirable, and how I can prove that the technology is actually behaving the way I think it should.

Understanding Instead of Memorizing

This repetition – starting with a small piece of the puzzle and slowly expanding the depth of your knowledge – allows you to move beyond memorization and retain information long-term.

This is the opposite of what I've seen many people try when learning advanced technologies. They often start by trying to memorize all the configuration steps needed to make the solution work. The problem with that approach becomes apparent when something goes wrong.

In the real world, you’ll eventually find yourself in an unfamiliar situation where the behavior you're seeing doesn't match your understanding of how the protocol or solution is supposed to work.

You might not remember every config command or every possible option, but a fundamental understanding of why something should work a certain way gives you a structured reasoning process for troubleshooting it. You can determine what should be happening, verify what is actually happening, and focus your troubleshooting efforts on understanding the difference.

Can You Explain It to Someone Else?

In my experience, the best way I can prove that this process is successful is whether I can explain the technology to someone who’s never used it before, and simplify it to a level where it no longer seems intimidating. That’s ultimately how I got into IT training.

When studying for my first CCIE, I found myself helping other students and peers in my class. Being able to explain a difficult concept in a way that helped someone else understand it demonstrated that I truly understood the technology myself. That lesson has stayed with me throughout my career.

Building Confidence for What Comes Next

The blessing (or maybe the curse) of working in IT is that things are constantly changing. New technologies are introduced, and old technologies are abandoned in favor of new, bright, shiny solutions.

The longer you're in this industry, though, the more you realize that things come in cycles. Today's solutions often turn out to be variations of concepts that aren't entirely new, but instead have been recycled, evolved, and repackaged over the years.

The challenge when looking at something new is that the amount of depth and detail can seem overwhelming. From the starting point, it can feel like you'll never truly understand how all of it works. By using this modular learning approach, though, you slowly start to chip away at the problem.

Start by understanding why the technology exists. Build something simple. Go back and learn the deeper details, then return to the lab and explore the advanced implementation.

A few months later, you’ll look back at where you started, and realize how far you've come. More importantly, having a structured and repeatable learning process gives you confidence. You don't need to know what technologies will emerge five or ten years from now. You just need to know that when something new arrives, you have a process for learning it.

The goal isn't to memorize everything. It’s to know that whatever comes next, you can understand it – one bite at a time.

Continue learning with Brian McGahan through INE’s training, and follow him on LinkedIn for more insights on networking, Cisco technologies, and professional development.