Cisco CCNA

Three foundations that every later topic leans on. You learn how Wi-Fi bands and channels work, what virtual machines and containers change in a network, and how TCP and UDP behave and when each is the right choice.

• Wi-Fi bands, channels and SSIDs
• Virtual machines, hypervisors and virtual switches
• Containers compared with virtual machines
• TCP: handshake, windowing and reliability
• UDP and the applications that prefer it
• Well-known ports

You build A packet capture annotated to show a TCP handshake and a UDP exchange.

Addressing is the skill that everything else rests on. You subnet by hand, size subnets to need, work with variable-length masks and plan an address scheme that leaves room to grow.

• Classful history and why it no longer matters
• Subnetting to a number of hosts or subnets
• Variable-length subnet masks
• Summarizing routes and address blocks
• Private ranges and special-purpose addresses
• Verifying addresses on a Cisco device

You build An addressing plan for a multi-site company using variable-length masks.

IPv6 is now part of everyday work. You read and write its addresses, tell the address types apart, see how hosts build their own addresses and configure it on router interfaces.

• Address notation and compression
• Global unicast, unique local and link-local
• Multicast and anycast
• EUI-64 and SLAAC
• Configuring IPv6 on interfaces
• Dual-stack operation

You build A dual-stack lab where hosts reach each other over IPv4 and IPv6.

VLANs split one switch into many networks. You create and assign VLANs, carry them over 802.1Q trunks, route between them, and use neighbor discovery protocols to check what is connected.

• Why VLANs exist and how they segment traffic
• Creating VLANs and assigning access ports
• 802.1Q trunks, native VLAN and allowed lists
• Router-on-a-stick and Layer 3 switch interfaces
• CDP and LLDP for discovering neighbors
• Verifying and troubleshooting VLAN faults

You build A multi-VLAN switched network with working routing between VLANs.

Redundant links make a network resilient, and a loop makes it fail. You bundle links into EtherChannels, understand how spanning tree elects a root and blocks loops, and tune Rapid PVST+ so traffic takes the path you want.

• Bundling links with LACP and PAgP
• Why Layer 2 loops are dangerous
• Root bridge election and port roles
• Rapid PVST+ states and convergence
• PortFast and BPDU Guard on access ports
• Verifying spanning tree with show commands

You build A redundant switch topology with a chosen root bridge and a bundled uplink.

Wireless needs a design and a way to manage it. You compare autonomous, controller-based and cloud-managed designs, learn AP modes, configure a WLAN on a controller, and reach devices by console, SSH or a management interface.

• Autonomous, controller-based and cloud-managed designs
• AP modes and how access points join a controller
• Creating a WLAN: SSID, VLAN and security
• Console, SSH and Telnet access
• Device management through a web interface
• Wireless client connection troubleshooting

You build A configured WLAN and secured remote management on a lab device.

Routers choose paths by reading a table. You learn how a longest-match lookup works, what administrative distance and metric decide, and how to build networks with static, default and floating static routes.

• Reading a routing table entry
• Longest prefix match and forwarding
• Administrative distance and metric
• Static and default routes
• Floating static routes for backup
• Troubleshooting a missing route

You build A multi-router network that is fully reachable using static and default routes.

Static routes do not scale, and a single gateway is a single point of failure. You run single-area OSPFv2, read neighbor and database output, and explain how HSRP and similar protocols keep a default gateway available.

• How OSPF neighbors form and exchange routes
• Router ID, network statements and interface settings
• DR and BDR election on shared segments
• Reading OSPF neighbor and database output
• First hop redundancy: HSRP and its relatives
• Troubleshooting adjacency problems

You build A single-area OSPF network with a redundant gateway for the user subnet.

These three services make a network usable. You translate private addresses with NAT, hand out addresses with a DHCP server and relay, and trace how a name becomes an address.

• Static NAT, dynamic NAT and PAT
• Configuring a DHCP server on a router
• DHCP relay across subnets
• How DNS resolves a name
• Verifying and troubleshooting each service

You build A lab where private hosts get addresses by DHCP and reach the internet through NAT.

A network you cannot observe is a network you cannot run. You synchronize clocks with NTP, collect events with syslog and SNMP, move files with TFTP and FTP, secure management with SSH, and explain how QoS marks and treats traffic per hop.

• NTP and why accurate time matters
• Syslog severity levels and logging destinations
• SNMP versions, managers and agents
• TFTP and FTP for images and configs
• Securing management access with SSH
• QoS: classification, marking, queuing and policing

You build A device configured for NTP, syslog, SNMP and SSH, with a QoS policy explained.

Security is built into every layer. You learn the vocabulary of threats and attacks, filter traffic with access lists, defend the switch edge with port security and DHCP snooping, and compare VPN types and WPA wireless security.

• Threats, vulnerabilities and attack types
• Authentication, authorization and accounting
• Standard and extended access lists
• Port security and DHCP snooping
• Dynamic ARP inspection
• Site-to-site and remote access VPNs
• WPA2 and WPA3 for wireless networks
• Passwords, MFA and user awareness

You build A hardened access switch and an ACL that permits only the traffic you intend.

Networks are increasingly managed as software. You see how controller-based networking differs from device-by-device work, call a REST API and read JSON, compare Ansible and Terraform, and weigh where AI helps operations and where it needs checking.

• Management, control and data planes
• Controller-based and software-defined networking
• REST APIs: methods, status codes and authentication
• Reading and writing JSON
• Ansible and Terraform at a glance
• AI in network operations: what to trust and what to check

You build A Python script that queries a network API and prints a readable device report.

Combine addressing, switching, routing, services and security in one design. You plan the addresses, configure each device, secure it, test it end to end and document what you built.

• Turning requirements into a design
• Building the switching and routing layers
• Adding NAT, DHCP, NTP and logging
• Applying access lists and Layer 2 protections
• Testing end to end and fixing faults
• Documenting the finished network

You build A complete multi-site lab network, verified end to end and fully documented.