DEV Community: Amir Taghanaki

Networking Fundamentals

Amir Taghanaki — Wed, 15 Jul 2026 15:43:12 +0000

Networking is one of those topics that sits underneath almost everything in IT, but it’s surprisingly easy to overlook when you’re first getting started.

Whether you’re deploying applications in AWS, managing Linux servers or working in DevOps, everything eventually comes back to devices communicating with one another. Until recently, I understood terms like router, switch and IP address individually, but I didn’t have a clear picture of how they all fit together.

This week, I worked through the Networks and Communications section of KodeKloud to build that foundation. Rather than memorising definitions, my goal was to understand how data actually moves from one device to another and what happens when something goes wrong.

⸻

The Problem

As someone transitioning into Cloud and DevOps, I knew networking would become unavoidable.

Cloud infrastructure relies heavily on networking concepts. Virtual networks, subnets, security groups, DNS, load balancers and Kubernetes networking all build upon the same core principles.

Before diving deeper into cloud technologies, I wanted to understand:

What actually makes up a network?
How do devices know where to send information?
What role does each piece of networking hardware perform?
How is data transported reliably?
How should networking problems be diagnosed?

Answering these questions would give me a much stronger foundation for future topics.

⸻

My Approach

Rather than jumping straight into advanced networking, I started with the fundamentals and built upwards.

I covered the material in the following order:

Networking Fundamentals
How the Internet Works
Network Hardware
Common Networking Protocols
Network Troubleshooting

Each section naturally built upon the previous one.

⸻

Networking Fundamentals

The first lesson completely changed how I think about networks.

At their simplest, networks are just groups of devices that exchange information and resources.

That communication doesn’t even require internet access.

Different network types simply describe their size.

PAN (Personal Area Network)

A PAN connects personal devices over a very short distance.

Examples include:

Phone
Smartwatch
Tablet
Wireless earbuds

Bluetooth is a common PAN technology.

⸻

LAN (Local Area Network)

A LAN connects devices within one physical location.

Examples include:

Home network
Office
School
Small business

If the LAN uses Wi-Fi instead of cables, it’s called a WLAN (Wireless Local Area Network).

⸻

WAN (Wide Area Network)

WANs connect devices across much larger geographical areas.

Examples include:

Different cities
Countries
Continents

The Internet itself is the world’s largest WAN.

⸻

Peer-to-Peer vs Client-Server

I also learned there are different ways devices communicate.

Peer-to-Peer

Every device communicates directly with the others.

Advantages:

Simple
Easy to configure
Good for small file sharing

Disadvantages:

Doesn’t scale well
Harder to manage

⸻

Client-Server

Instead of devices talking directly, everything communicates through a central server.

Benefits include:

Better scalability
Central management
Easier security
Better reliability

This architecture is used almost everywhere in modern computing.

⸻

Understanding the Internet

One misconception I previously had was believing IP addresses uniquely identify every device.

That’s only part of the story.

I learned there are two important addresses involved.

MAC Address

A MAC address identifies the physical network interface on a local network.

Think of it as the device’s hardware identity.

⸻

IP Address

An IP address identifies where information should be delivered across networks.

Routers use IP addresses to determine where packets should travel.

⸻

Packets

Another interesting concept was packet switching.

Instead of sending one enormous file across the network, data is broken into many small packets.

Each packet can:

Travel independently
Take different routes
Be retransmitted if lost

This makes communication much more reliable and allows many devices to share the same network simultaneously.

Routers forward packets one hop at a time until they eventually reach their destination.

⸻

Network Hardware

One of the biggest improvements this week was finally understanding what each networking device actually does.

Modem

The modem connects your home network to your Internet Service Provider (ISP).

Without it, there is no internet connection.

⸻

Router

The router acts as the traffic manager.

It:

Connects different networks
Assigns IP addresses using DHCP
Routes traffic between your devices and the internet

⸻

Switch

A switch expands the number of wired devices that can connect to a network.

Unlike a hub, switches intelligently send traffic only where it’s needed.

⸻

Wireless Access Point (WAP)

A WAP extends wireless coverage.

Large offices often have many WAPs working together to provide seamless Wi-Fi throughout a building.

⸻

Network Topologies

I also learned that network performance isn’t determined only by hardware.

The layout of the network matters too.

Some common topologies include:

Star

Every device connects to one central switch.

Advantages:

Easy troubleshooting
Fault isolation
Most common today

⸻

Mesh

Devices have multiple paths between one another.

Benefits:

High redundancy
Excellent resilience

Often used where uptime is critical.

⸻

Bus

All devices share one communication cable.

While historically important, it’s largely obsolete because a single cable failure can disrupt the whole network.

⸻

Protocols

Protocols are simply agreed rules that allow devices to communicate.

The TCP/IP model explains how information moves between computers.

Data travels through several layers during transmission.

This process is called encapsulation.

When the receiving device processes the information, those layers are removed in reverse order through decapsulation.

I also covered several common protocols:

DHCP automatically assigns private IP addresses.
HTTPS encrypts communication between browsers and websites.
SMTP is responsible for sending email.
UDP prioritises speed over guaranteed delivery.
Port numbers ensure traffic reaches the correct application.

Seeing how each protocol solves a specific problem made networking feel much less abstract.

⸻

Network Troubleshooting

The troubleshooting section was probably my favourite.

Rather than immediately assuming complicated failures, I learned the value of following a logical process.

A typical workflow might look like this:

Check physical cables and hardware.
Confirm the router is powered on.
Verify IP configuration.
Ping the local router.
Ping 8.8.8.8 to test internet connectivity.
Verify DNS settings.
Use traceroute to identify where packets stop travelling.
Ensure DHCP is assigning addresses correctly.

Breaking troubleshooting into small, logical steps makes problems much easier to isolate.

⸻

Key Lessons

Networks don’t require internet to function.
Every networking device has a specific responsibility.
Data travels as packets rather than one continuous stream.
TCP/IP provides the framework that makes communication possible.
Effective troubleshooting starts with the simplest checks before investigating more complex causes.

⸻

What I’d Do Differently

Looking back, I probably spent too much time memorising networking terminology in the past instead of understanding the concepts behind it.

This time I focused on asking why each technology exists and what problem it solves. That made everything much easier to connect together, especially once I reached the troubleshooting section.

As I continue learning, I also want to spend more time practising these concepts in a lab environment rather than only reading about them. Building and troubleshooting small networks myself will help reinforce what I’ve learned.

⸻

Next Steps

Networking is one of the core foundations of Cloud and DevOps, so this is only the beginning.

Next, I’ll continue building on these fundamentals while moving further into networking concepts before applying them to cloud infrastructure, where understanding how systems communicate becomes even more important.

Computer Architecture and Operating Systems

Amir Taghanaki — Wed, 01 Jul 2026 10:57:27 +0000

When people think about getting into Cloud or DevOps, it’s easy to jump straight into technologies like Kubernetes, Docker or AWS. I felt that temptation too. After all, those are the tools that appear in job descriptions and technical discussions.

Over the past week, though, I’ve been working through the IT Fundamentals course on KodeKloud, and it’s reminded me why building a strong foundation matters.

Rather than focusing on cloud platforms, I’ve been learning how computers actually work beneath the surface. Topics like memory, storage, data buses, operating systems and applications might not seem exciting at first, but they’re the building blocks that everything else relies on.

The more I learn, the more I realise that understanding these fundamentals makes the more advanced topics feel much less intimidating.

The Problem

As someone transitioning from hospitality into Cloud and DevOps, I don’t want to become someone who can follow tutorials without understanding what’s happening underneath.

It’s possible to memorise commands, deploy cloud resources and even automate infrastructure without really understanding how a computer processes information. But eventually those gaps show up when something doesn’t work as expected.

I wanted to strengthen that foundation before moving deeper into Linux, networking and cloud technologies.

My Approach

I’ve been working through the IT Fundamentals course on KodeKloud, taking my time with each section rather than trying to finish it as quickly as possible.

Instead of simply watching the lessons, I’ve been making notes, sketching diagrams and stopping regularly to think about why each component exists and how it interacts with everything else.

The topics I’ve been studying include:

CPU fundamentals
RAM and system memory
Storage devices
Data buses
Motherboards
Operating systems
Applications and software
Basic hardware architecture

One thing I’ve found particularly useful is relating each topic back to the computers I use every day instead of treating everything as abstract theory.

Understanding Computer Architecture
Before this week, I knew that computers contained a CPU, memory and storage.

Now I have a much better understanding of how they actually work together.

A simplified version of the process looks something like this:

When an application starts, it isn’t running directly from the SSD.

The operating system loads the required files from storage into RAM because RAM is dramatically faster than permanent storage. The CPU then continuously fetches instructions and data from memory while executing the program.

That also helped explain why having enough RAM makes such a noticeable difference to performance. Even a fast SSD is significantly slower than RAM, so if the operating system constantly needs to move data between memory and storage, everything starts to feel sluggish.

Understanding this relationship made the purpose of each hardware component much clearer.

Memory vs Storage

One of the concepts I wanted to understand properly was the difference between memory and storage.

At first glance they can seem similar because both hold data, but they serve very different purposes.

RAM is temporary working memory.

It stores the information that the CPU needs immediate access to while programs are running. Once the computer is powered off, that information disappears.

Storage, on the other hand, is permanent.

Whether it’s an SSD or HDD, it keeps your operating system, applications and personal files even when the machine is switched off.

Thinking about RAM as a workbench and storage as a warehouse made the distinction much easier to remember.

Understanding Data Buses
Another topic that I previously knew very little about was data buses.

I’d heard the term before but never really understood what they did.

The data bus acts as a communication pathway that allows information to move between components such as:

CPU
RAM
Storage
Input and output devices

Without these communication pathways, each hardware component would effectively be isolated.

Learning about buses also helped explain why motherboard design matters. It’s not simply about connecting components together—it influences how efficiently information moves around the entire system.

Operating Systems and Applications

One of the biggest takeaways this week has been understanding the role of an operating system.

Before, I thought of Windows or Linux simply as the software you interact with.

Now I see the operating system as the layer that manages the computer’s resources.

It handles responsibilities such as:

Managing memory allocation
Scheduling CPU time
Managing storage
Handling hardware devices
Running applications
Providing security and permissions

Applications don’t communicate directly with hardware.

Instead, they make requests to the operating system, which then interacts with the underlying hardware on their behalf.

That separation makes much more sense now than it did before.

It’s also made me appreciate why Linux knowledge is so valuable in Cloud and DevOps.

Understanding how an operating system manages resources will become increasingly important as I continue learning servers, containers and cloud infrastructure.

Challenges

The biggest challenge wasn’t memorising terminology.

It was understanding how all the components fit together as one system.

Initially I found myself learning each topic in isolation:

CPU
RAM
Storage
Motherboard
Operating system

But eventually I realised that’s not how computers actually work.

Each component constantly depends on the others.

Once I started thinking about the complete journey—from opening an application, to loading data from storage, into memory, being processed by the CPU, and displayed on screen—the individual concepts became much easier to understand.

Slowing down and connecting those ideas together has helped far more than trying to memorise definitions.

Key Lessons

Strong technical foundations make advanced topics much easier to learn.
Understanding why something works is more valuable than simply remembering terminology.
Computer components are designed to work together as a complete system rather than independently.
Operating systems play a much larger role than simply providing a user interface.
Taking time to build conceptual understanding leads to better long-term retention than rushing through a course.

What I’d Do Differently

Looking back, I probably would have started learning these fundamentals earlier.

When you’re eager to work in Cloud or DevOps, it’s tempting to jump straight into AWS or Kubernetes because those technologies seem more exciting.

I’m beginning to appreciate that understanding what’s happening underneath makes those higher-level technologies much easier to grasp.

Going forward, I’d also like to spend more time reinforcing these concepts with practical exercises alongside the theory. Reading is useful, but applying what I’ve learned will help those ideas stick.

Next Steps

My focus over the next few weeks is to continue progressing through the KodeKloud IT Fundamentals course while strengthening my understanding of Linux and networking.

Once these fundamentals are firmly in place, I’ll feel much more confident moving into cloud infrastructure, automation and DevOps tools.

Building a career in technology isn’t about rushing through courses. For me, it’s about building knowledge layer by layer so that each new concept has something solid to stand on.