​

Architecture Layering Cheatsheet

​

Why Layers Matter

​

The Full Stack: 7 Layers, 4 Languages

​

Layer-by-Layer Reference

​

Layer 1: Physical

​

Layer 2: Data Link

​

Layer 3: Network / IP

# Python — raw ICMP with scapy
python3 -c "from scapy.all import *; print(sr1(IP(dst='1.1.1.1')/ICMP()))"

# Go
go run -c "net.Dial('ip4:icmp', '1.1.1.1')"

​

Layer 4: Transport / TCP

# Python — raw socket connect test
import socket
s = socket.create_connection(("host", 22), timeout=5)
print(f"Connected: {s.getpeername()}")
s.close()

// Node.js — TCP connect test
const net = require("net");
const s = net.connect(22, "host", () => {
  console.log("Connected");
  s.end();
});
s.on("error", (e) => console.error(e.message));
s.setTimeout(5000);

// Rust — TCP connect test
use std::net::TcpStream;
use std::time::Duration;
let stream = TcpStream::connect_timeout(
    &"host:22".parse().unwrap(),
    Duration::from_secs(5)
);

// Go — TCP connect test
conn, err := net.DialTimeout("tcp", "host:22", 5*time.Second)
if err != nil { log.Fatal(err) }
defer conn.Close()

​

Layer 5: Auth / Protocol Negotiation

# Python paramiko — uses traditional publickey auth
import paramiko
client = paramiko.SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect('host', username='root', key_filename='/path/to/key')
# If this works but `ssh` doesn't → protocol extension issue

// Node ssh2 — also uses traditional publickey
const { Client } = require("ssh2");
const conn = new Client();
conn.on("ready", () => {
  console.log("Connected");
  conn.end();
});
conn.connect({
  host: "host",
  username: "root",
  privateKey: fs.readFileSync("/path/to/key"),
});

// Rust russh — control over auth method
use russh::*;
// Explicit key auth without hostbound extension

// Go x/crypto/ssh — explicit auth method selection
config := &ssh.ClientConfig{
    User: "root",
    Auth: []ssh.AuthMethod{ ssh.PublicKeys(signer) },
}
conn, err := ssh.Dial("tcp", "host:22", config)

​

Layer 6: Presentation / Session (TLS, Encryption, Encoding)

​

Layer 7: Application

​

The Debugging Flowchart

​

Quick Reference: Tools by Scenario

​

”I can’t connect to anything"

ip link show                    # Is the interface up?
ping 8.8.8.8                   # Can you reach the internet at all?
ping <gateway-ip>              # Can you reach your router?
dig google.com                 # Is DNS working?
traceroute <target>            # Where do packets die?

​

"I can ping but can’t connect to the service"

nc -zv <host> <port>           # Is the port open?
ss -tlnp                       # Is the service listening? (on server)
iptables -L -n                 # Is a firewall blocking it? (on server)
ufw status                     # UFW firewall rules (Ubuntu)

​

"Connection establishes but auth fails"

ssh -vvv user@host             # Client-side auth debug
sshd -d -p 2222               # Server-side auth debug (run on server)
openssl s_client -connect h:443 # TLS handshake debug
ssh -V                         # Check OpenSSH version (10.2+ uses new auth)

​

"SSH specifically: ‘Connection closed [preauth]‘"

# THE cheatsheet for this exact problem:
sshd -d -p 2222                      # 1. Server debug — see what actually arrives
ssh -v -p 2222 user@host             # 2. Client verbose — see what's sent
ssh -V                                # 3. Check version — 9.8+ uses publickey-hostbound
pip install paramiko && python3 -c "
import paramiko
c = paramiko.SSHClient()
c.set_missing_host_key_policy(paramiko.AutoAddPolicy())
c.connect('host', username='root', key_filename='~/.ssh/id_rsa')
print('paramiko connected')
c.close()
"                                     # 4. If paramiko works → protocol extension issue
cat /etc/os-release                   # 5. Ubuntu 24.04? Service is 'ssh' not 'sshd'

​

"It works locally but not from CI/CD or another server”

# Check what the OTHER machine sees:
curl -s ifconfig.me                   # What's my public IP?
mtr <target>                          # What path do my packets take?
ssh -o PreferredAuthentications=publickey user@host  # Force specific auth method

​

Language Comparison: Connection Debugging Patterns

​

The Same Bug, Four Ways

​

Key Insight: Library vs. System Implementation

​

Infra Patterns: Boxes and Arrows

​

Campaign: Cross-Platform Strategy

​

Twitter/X Thread (4 tweets)

I made an infrastructure debugging cheatsheet that maps every network layer to its tools — in Bash, Python, Node, Rust, and Go. Born from 4 hours of debugging a ghost packet that vanished between two servers. Bookmark this. :thread:

The flowchart: Can you ping it? No → Layer 1-3 Can you TCP connect? No → Layer 4 Does the handshake complete? No → Layer 5-6 Does the app respond? No → Layer 7 Four questions. That’s all you need.

The insight that changed my debugging forever: When OpenSSH fails but paramiko succeeds with the same key to the same server — it’s not your key. It’s the PROTOCOL EXTENSION. OpenSSH 10.2+ uses a different (larger) auth packet. Some network paths drop it.

Full cheatsheet with mermaid diagrams, language comparisons, and copy-paste command blocks: [link] Plus the companion blog post telling the full debugging story: [link]

​

LinkedIn Post

Every infrastructure failure lives at a specific layer. I just published an Architecture Layering Cheatsheet — a practical guide to debugging any infrastructure problem by working through the network stack layer by layer. It maps each layer to its debugging tools across Bash, Python, Node, Rust, and Go. Includes a four-question flowchart that locates the failure layer in under a minute. Born from a real debugging session where an SSH connection failed silently — no error at any individual layer. The failure existed between layers, in the interaction between a new protocol extension and the network path. Bookmark it, print it, tape it to your monitor. The next time something breaks and “everything looks fine,” this will save you hours. [link] #DevOps #Networking #Debugging #InfraEngineering #Cheatsheet #SSH #Architecture

​

Instagram (Carousel — 8 slides)

1. Cover: “ARCHITECTURE LAYERING CHEATSHEET” — clean, terminal-aesthetic design
2. The Rule: “Work bottom-up. Confirm each layer before moving up.” — minimal text, bold
3. Layer 1-3: Physical / Data Link / Network — key commands (ping, traceroute, dig)
4. Layer 4: Transport — TCP debugging (nc, ss, tcpdump)
5. Layer 5-6: Auth / TLS — the ghost layer (ssh -v, sshd -d, openssl)
6. Layer 7: Application — app-level debugging (curl, health checks)
7. The Flowchart: Simplified 4-question decision tree
8. CTA: “Full cheatsheet with language comparisons at [link]” — save this post

​

Short-Form Video (45-60s)

• Cross out Layer 1 (“cable’s plugged in”)
• Cross out Layer 3 (“ping works”)
• Cross out Layer 4 (“TCP connects”)
• Circle Layer 5 in red (“THE HANDSHAKE. This is where the ghosts are.”)
• Show the four-question flowchart

​

Newsletter Section

New Reference: Architecture Layering Cheatsheet I’ve published the companion piece to this week’s debugging story — a practical cheatsheet that maps every network layer to its debugging tools across five language ecosystems. The core insight: work bottom-up, confirm each layer is clean before moving up, and when “everything looks fine” at every layer individually, look at the interactions between layers. That’s where the ghosts live. This is designed as an evergreen reference — the kind of thing you bookmark and pull up six months from now when something breaks at 3am. [Architecture Layering Cheatsheet →]

​

SEO Strategy: Making This the Reference

​

Target SERP Position

​

Content Structure for SEO

1. H1: Architecture Layering Cheatsheet (matches “cheatsheet” queries)
2. H2s: Each layer name (matches “Layer N debugging” queries)
3. Tables: Scannable, featured-snippet friendly
4. Code blocks: Copy-paste commands (matches “how to debug X” queries)
5. Flowchart: Visual, shareable, linkable anchor
6. Language comparison: Unique differentiator vs. existing cheatsheets (most are Bash-only)
7. Real-world examples: Not textbook OSI — real failures from a real session

​

Backlinking Strategy

​

Schema Markup Recommendations

{
  "@type": "TechArticle",
  "name": "Architecture Layering Cheatsheet",
  "description": "Debug any infrastructure problem layer by layer",
  "proficiencyLevel": "Expert",
  "dependencies": "Linux, SSH, TCP/IP networking",
  "about": ["Network debugging", "SSH troubleshooting", "Infrastructure"]
}

​

Virality Boosters

​

Emojis

• :mag: for debugging steps
• :ghost: for the ghost packet reference
• :bookmark: for “save this” CTAs
• :white_check_mark:/:x: for pass/fail in checklists
• :brain: for the mental model / flowchart

​

GIF Ideas

• “It’s a series of tubes” (Senator Stevens) — for the “arrows matter” section
• “Enhance” CSI zoom — for going layer by layer
• “I’m in” hacker movie trope — for when the flowchart finally locates the layer

​

Content Cadence Placement

​

Extra Opportunities

​

Spin-Off Content

1. “Architecture Layering Cheatsheet: Cloud Edition” — AWS/GCP/Azure-specific tools per layer (VPC flow logs, Cloud Armor, etc.)
2. “Architecture Layering Cheatsheet: Kubernetes Edition” — Pod networking, service mesh, CNI plugin debugging
3. Printable PDF version — gated download for email list building
4. Interactive web version — click a layer, see the tools + examples expand (Mintlify interactive blocks)

​

Interactive Audience Prompts

• “Which layer do YOU get stuck on most? (Poll: DNS / Firewall / Auth / App)”
• “What’s your go-to first debugging command when something breaks? Drop it below.”
• “Has anyone else hit the publickey-hostbound-v00 issue? I want to map which ISP/hosting combos trigger it.”

​

Collaboration Angles

• Julia Evans (b0rk) — her zine format + this content = perfect match. She’s done networking zines before.
• Cloudflare blog — they write about middlebox/protocol issues regularly. Pitch a guest post.
• Hostinger blog — “Debugging SSH on Hostinger VPS” version targeted at their customer base.