学習を始める→
ホーム/ロードマップ/Software Engineering & Distributed Systems

Full-Stack & Distributed Systems Architecture

Master software engineering at production scale. Move beyond basic CRUD apps to event-driven architectures, write-ahead logging databases, Redis caching topologies, and zero-downtime distributed deployments.

Total Effort:~380 Hours
Pace:32 Weeks (~12h/wk)
Rigor:Beginner to Professional
"You Are Here" Progress Tracker
0 of 3 Nodes Mastered
•
0% Complete
01
Phase 1Systems Foundation

Networking Protocols, Memory & Modern Backend

HTTP/2 & HTTP/3 QUIC, TCP handshakes, TLS 1.3, asynchronous I/O event loops, and relational data modeling.

1Learner Experience Window
⚡The Wall of Abstraction

What you're experiencing: "Event Loops & Concurrency"

You thought web development was just sending JSON, until you encounter connection pool exhaustion and database locks. You realize performance is an engineering discipline.

What your internal monologue sounds like right now:
“Why did my database crash when 50 concurrent requests hit a loop without connection pooling?”
“Understanding non-blocking I/O (epoll/kqueue) completely changed how I think about server throughput.”
Neurobiology of this stage

You are shifting from writing sequential scripts to architecting asynchronous server systems capable of servicing 100,000 concurrent sockets.

⚠️ Pitfall to dodge:
  • Performing N+1 database queries inside loops instead of batch fetching or JOIN queries.
  • Not setting connection pool timeouts and socket read deadlines, causing thread worker starvation.
Sanity Check & Breakthrough Tactic
Inspect raw HTTP headers and TLS handshakes using `curl -v` and Wireshark. Demystify the wire protocol.
Remember: Discomfort is evidence of synaptic adaptation.Keep coding →
Networking•Intermediate

Computer Networking: TCP, HTTP/2, QUIC & TLS 1.3

Socket lifecycle, TCP flow control, head-of-line blocking, and cryptographic TLS handshakes.

⏱️ ~30h•2 Elite Resources
Data Storage•Intermediate

Relational Database Internals & Indexing

B-Trees, Write-Ahead Logs (WAL), MVCC concurrency control, and query execution plans in PostgreSQL.

⏱️ ~35h•2 Elite Resources
Capstone Checkpoint⏱️ ~20h Portfolio Spec
Intermediate

Capstone: Distributed Token-Bucket Rate Limiter with Redis & Lua

Implement a zero-race-condition distributed API rate limiter supporting Sliding Window Counter and Token Bucket algorithms using atomic Redis Lua scripts with microsecond latency guarantees.

Required Proof-of-Competence Deliverables:
Atomic Lua script executed on Redis server preventing race conditions under high concurrency
Express/Fastify/Go HTTP middleware returning standardized 429 Retry-After headers
Locust/k6 load test suite validating 20,000 req/sec throughput under load
02
Phase 2Distributed Systems

Distributed Systems & Data at Scale

Distributed consensus (Raft/Paxos), event-driven messaging (Kafka), caching topologies, and partition tolerance.

2Learner Experience Window
💡The Aha! Breakthrough

What you're experiencing: "Eventual Consistency & Raft Consensus"

You stop thinking in terms of single-server guarantees. You realize network partitions, clock skew, and partial server crashes are inevitable realities.

What your internal monologue sounds like right now:
“CAP theorem isn't just theory — network partitions happen in real clouds all the time.”
“Eventual consistency requires idempotency keys and outbox patterns to prevent double payments.”
Neurobiology of this stage

You have elevated from developer to system architect. You design systems where any node can fail without bringing down the platform.

⚠️ Pitfall to dodge:
  • Assuming wall-clock time (`Date.now()`) is monotonically synchronized across different servers.
  • Not designing consumers with idempotency, causing duplicate charge/processing during message retries.
Sanity Check & Breakthrough Tactic
Read the "Secret Lives of Data" visual Raft consensus tutorial. Step through leader election visually.
Remember: Discomfort is evidence of synaptic adaptation.Keep coding →
Distributed Systems•Advanced

Distributed Architecture & Consensus (Raft/Paxos)

CAP theorem, linearizability, vector clocks, leader election, and distributed consensus.

⏱️ ~45h•3 Elite Resources
Capstone Checkpoint⏱️ ~30h Portfolio Spec
Advanced

Capstone: Event-Driven Order Processing Engine with Transactional Outbox

Build an event-driven microservice system with PostgreSQL and Apache Kafka. Implement the Transactional Outbox Pattern with Debezium CDC to guarantee exactly-once event delivery, inventory reservations, and payment processing.

Required Proof-of-Competence Deliverables:
PostgreSQL transactional outbox table populated within same database transaction as order record
CDC publisher streaming change events to Kafka topic
Idempotent payment consumer service with dead-letter queue (DLQ) retry routing