# Network Engineering

Network Engineering is the discipline of designing, implementing, operating, and troubleshooting communication networks. It provides the connectivity foundation for distributed systems, cloud infrastructure, and agentic systems that call tools and APIs over the network.

This vault is a **staging ground for educational content**, not a reference dump. Every note is written to be taught: it defines the term, shows the dynamic (what moves, in what order), and names where the thing breaks.

## Philosophy

> *"Packets don't lie. If you understand how packets flow, you can debug almost anything."*

Networks are classic engineered systems — clear requirements, well-defined interfaces, trade studies, verification. They also have the highest ratio of *confident wrong mental models* to actual complexity of any discipline in software, which is why every note here carries a "where it goes wrong" section.

## Vault Structure

```
Network Engineering/
├── README.md
├── Foundations/                    # models, encapsulation, addressing, terminology, design
│   ├── OSI-TCPIP-Models.md
│   ├── Packet-Flow-Encapsulation.md
│   ├── Addressing-Subnetting-CIDR.md
│   ├── Ethernet-ARP-And-Local-Delivery.md
│   ├── Network-Design-And-Topologies.md
│   └── Network-Terminology.md
├── Core-Protocols/                 # IP, TCP/UDP, DNS/DHCP/ICMP, ports, TLS, HTTP/QUIC
├── Switching-LAN/                  # VLANs, STP, wireless
├── Routing/                        # fundamentals, route selection, OSPF, BGP
├── Network-Services/               # NAT, load balancing, firewalls/ACLs, NTP
├── Security/                       # fundamentals, zero trust, VPNs, DDoS
├── Cloud-Modern-Networking/        # VPCs, cloud patterns, overlays/SDN/VXLAN
├── Automation-Observability/       # NetDevOps, telemetry, packet analysis
├── Labs/                           # home lab, troubleshooting scenarios, subnetting drills
└── Pedagogy/                       # teaching sequence, mistake taxonomy, course blueprint
```

## Quick Navigation by Goal

| If you're... | Start Here |
|---|---|
| **New to networking** | `Foundations/OSI-TCPIP-Models.md` → `Foundations/Packet-Flow-Encapsulation.md` |
| **Learning the vocabulary** | `Foundations/Network-Terminology.md` |
| **Learning addressing/subnetting** | `Foundations/Addressing-Subnetting-CIDR.md` → `Labs/Subnetting-Drills.md` |
| **Understanding the first hop** | `Foundations/Ethernet-ARP-And-Local-Delivery.md` |
| **Configuring switched networks** | `Switching-LAN/VLANs-Trunking.md` → `Switching-LAN/STP-And-Loop-Prevention.md` |
| **Learning routing** | `Routing/Routing-Fundamentals.md` → `Routing/Route-Selection-And-Metrics.md` → `Routing/OSPF-Fundamentals.md` |
| **Understanding the internet** | `Routing/BGP-And-Internet-Routing.md` |
| **Core protocols** | `Core-Protocols/IP-TCP-UDP.md` → `Core-Protocols/Ports-And-Services.md` |
| **Web traffic end to end** | `Core-Protocols/TLS-And-HTTPS.md` → `Core-Protocols/HTTP-Versions-And-QUIC.md` |
| **NAT and publishing a service** | `Network-Services/NAT-And-PAT.md` → `Network-Services/Load-Balancing.md` |
| **Firewall confusion** | `Network-Services/Firewalls-And-ACLs.md` |
| **Network security** | `Security/Network-Security-Fundamentals.md` → `Security/Zero-Trust-And-Segmentation.md` |
| **Cloud networking** | `Cloud-Modern-Networking/VPC-Fundamentals.md` → `Cloud-Modern-Networking/Cloud-Networking-Patterns.md` |
| **Data-centre fabrics / SDN** | `Cloud-Modern-Networking/Overlays-SDN-VXLAN.md` |
| **Debugging issues** | `Labs/Troubleshooting-Scenarios.md` → `Automation-Observability/Packet-Analysis-Wireshark.md` |
| **Automating networks** | `Automation-Observability/NetDevOps-Fundamentals.md` |
| **Teaching this to someone** | `Pedagogy/Course-Blueprint.md` → `Pedagogy/Teaching-Sequence-And-Analogies.md` |
| **Writing a course or lesson** | `Pedagogy/Where-It-Goes-Wrong.md` |

## The Teaching Layer

Three notes exist specifically for building the course, and they are the reason the rest is usable as a syllabus:

| Note | What it provides |
|---|---|
| `Pedagogy/Course-Blueprint.md` | Ten modules, minute budget, terms per module, diagram, interaction, mistake, quiz angle |
| `Pedagogy/Teaching-Sequence-And-Analogies.md` | The order, one analogy per concept, what to cut, how to assess understanding |
| `Pedagogy/Where-It-Goes-Wrong.md` | Mistakes by layer: conceptual, address planning, configuration, operational, security |

Every content note ends with a **Where it goes wrong** section and a **Teaching hook** (one analogy, one demo). That is the pattern for any new note in this vault.

## Core Principles

1. **Packet-first thinking** — follow the packet end-to-end
2. **Define, then show the dynamic, then show the failure** — the teaching order
3. **Longest prefix wins** — before metrics, before policy
4. **Layers are a debugging tool** — not a syllabus
5. **Redundancy needs independence and a test** — or it is a diagram
6. **Security by design** — segmentation and least privilege, not a product
7. **Observable** — if you can't see it, you can't fix it
8. **Automate** — networks should be version-controlled

## Bridging to Other Wikis

- **Systems Engineering** — network design uses requirements, trade studies, interface management
- **Software Engineering** — APIs, load balancers and service meshes are network-aware software
- **Agentic Engineering** — MCP over the network, tool calling to remote APIs, agent-to-agent traffic, sandbox networking

## Key Skills for Modern Engineers

| Skill | Why |
|---|---|
| **Packet analysis** | Debug connectivity faster than any dashboard |
| **Subnetting/CIDR** | Essential for cloud and VPC design |
| **Routing fundamentals** | Understand why traffic takes the path it does |
| **DNS and TLS** | The two most common causes of "the site is down" |
| **Load balancing** | Where availability is actually engineered |
| **Cloud networking** | Most traffic now crosses a VPC |
| **Network automation** | Config as code, drift as a bug |

## Contributing

1. Practical, lab-able content; every claim should be reproducible
2. Include a packet walkthrough where helpful
3. Add Wireshark tips and exact commands, not descriptions of commands
4. Use mermaid for topologies and sequences
5. Link related notes across wikis
6. Every note ends with **Where it goes wrong** and **Teaching hook**

## Sources

* Cisco CCNA/CCNP materials (concepts)
* TCP/IP Illustrated (Stevens)
* Computer Networking: A Top-Down Approach (Kurose & Ross)
* Cloud provider documentation (AWS VPC, Azure VNet, GCP VPC)
* Wireshark documentation and sample captures
* RFCs for core protocols (791, 793, 1035, 1918, 2131, 3021, 8446, 9000)
* Public post-mortems and incident write-ups for the failure examples