When developers face network slowness, a systematic OSI layer approach works best. Start with physical connectivity (Layer 1) using cable testers or switch port statistics, then verify data link layer (Layer 2) with ARP tables and MAC address tables. For example, check switch port errors:

# Cisco switch
show interface gigabitethernet1/0/1 counters errors

# Linux ethtool
ethtool -S eth0 | grep -i error

Wireshark remains the gold standard for deep packet inspection. Developers should filter for TCP retransmissions, duplicate ACKs, and zero window conditions. Example capture filter for retransmissions:

tcp.analysis.retransmission || tcp.analysis.fast_retransmission

iperf3 provides real network throughput testing between endpoints. For continuous monitoring, implement SNMP polling for interface statistics:

# Server mode
iperf3 -s

# Client test (10 sec test)
iperf3 -c server_ip -t 10

Network slowness often stems from DNS issues or application bottlenecks. Use dig for DNS troubleshooting and implement HTTP/2 prioritization in web apps:

dig +trace example.com
dig @8.8.8.8 example.com

Python scripts using Scapy or socket can automate repetitive tests. This example checks TCP connection latency:

import socket
import time

def test_latency(host, port, runs=5):
    delays = []
    for _ in range(runs):
        start = time.time()
        with socket.create_connection((host, port), timeout=5):
            end = time.time()
            delays.append((end-start)*1000)
    return sum(delays)/len(delays)

print(f"Average latency: {test_latency('example.com', 80):.2f}ms")

For broadcast storms or switching loops, examine STP topology and broadcast rates. Modern switches provide storm control:

# Check broadcast rates
show interface | include Broadcast
show spanning-tree root

In Kubernetes environments, use kubectl and service mesh tools like Istio for network visibility:

kubectl get --raw /api/v1/namespaces/default/pods/test-pod:8080/proxy/metrics

---

Always start with the physical layer. A simple cable tester can reveal:

# Example cable test result interpretation
if (cable_test.status == "OPEN"):
    print("Check termination points for RJ45/T568B standard")
elif (cable_test.crosstalk > 3dB):
    print("Replace cable - excessive interference detected")

For fiber connections, use an OTDR to check for signal degradation. Common issues include dirty connectors (clean with lint-free swabs) or macrobends exceeding manufacturer specifications.

Modern switches provide CLI access for deep diagnostics:

# Cisco IOS example (similar syntax available on Juniper/Aruba)
show interface gigabitethernet1/0/1 
# Key metrics to check:
# - Input/Output errors (should be zero)
# - CRC errors (indicate physical layer issues)
# - Runts/giants (MTU mismatches)
# - Broadcast storm control triggers

Enable port mirroring for suspicious traffic:

monitor session 1 source interface gi1/0/1 both
monitor session 1 destination interface gi1/0/24

Use Wireshark with display filters for targeted analysis:

# Common Wireshark filters for performance issues
tcp.analysis.duplicate_ack || tcp.analysis.retransmission
dns.time > 1
http.time > 2

For broadcast storms, create a statistics capture:

tshark -i eth0 -q -z io,stat,60,"COUNT(frame) frame" -f "ether broadcast"

When dealing with SQL performance over networks:

# MySQL network performance metrics
SHOW GLOBAL STATUS LIKE 'Bytes_received';
SHOW GLOBAL STATUS LIKE 'Bytes_sent';
SHOW GLOBAL STATUS LIKE 'Aborted_connects';

For web applications, Chrome DevTools provides network waterfall analysis:

// Programmatic access to Navigation Timing API
const [entry] = performance.getEntriesByType("navigation");
console.log(DNS: ${entry.domainLookupEnd - entry.domainLookupStart}ms);
console.log(TCP: ${entry.connectEnd - entry.connectStart}ms);

Implement these SNMP OIDs for baseline monitoring:

# Interface utilization
IF-MIB::ifInOctets
IF-MIB::ifOutOctets

# Error counters
IF-MIB::ifInErrors
IF-MIB::ifOutErrors

# CPU/memory for network devices
OLD-CISCO-CPU-MIB::avgBusy5
CISCO-MEMORY-POOL-MIB::ciscoMemoryPoolUsed

For intermittent issues, consider packet capture with precision timing:

# Linux precision capture with nanosecond timestamps
tcpdump -i eth0 -j adapter_unsynced -w capture.pcap

Use Python for automated baseline comparisons:

import speedtest, time
def network_health_check():
    baseline = {
        'latency': 25,  # ms
        'download': 90, # Mbps
        'upload': 20    # Mbps
    }
    s = speedtest.Speedtest()
    current = {
        'latency': s.results.ping,
        'download': s.results.download / 1e6,
        'upload': s.results.upload / 1e6
    }
    return {k: current[k] - baseline[k] for k in baseline}