Srajan Saxena
aka Invincible Axonian
Software Engineer·Distributed Systems
I build systems that keep working when things go wrong.
Backend and distributed systems in Go, TypeScript, and Rust. Focused on fault tolerance, concurrency, and understanding how systems actually work—from application layer down to kernel and network.
Featured Projects
Systems I've designed and built to solve real distributed systems challenges. Each project explores different aspects of fault tolerance, scalability, and system design.
go-saga-axon
DAG-based saga orchestration for distributed transactions
┌─────────────────────┐
│ Saga Orchestrator │
└──────────┬──────────┘
│
┌──────────▼──────────┐
│ DAG Engine │
└──────────┬──────────┘
│
┌────────────────────┼────────────────────┐
│ │ │
▼ ▼ ▼
┌────────────┐ ┌────────────┐ ┌────────────┐
│ Payment │ │ Inventory │ │ Shipping │
└─────┬──────┘ └─────┬──────┘ └─────┬──────┘
│ │ │
▼ ▼ ▼
SUCCESS FAILURE SUCCESS
│
┌─────────▼─────────┐
│ Compensation │
└─────────┬─────────┘
│
┌─────────▼─────────┐
│ Event Log │
└───────────────────┘DAG-based orchestration with automatic compensation
Production-grade DAG-based saga orchestration engine for Go. Coordinates distributed transactions across microservices with automatic compensation, timeout monitoring, CQRS event sourcing, and split idempotency — built to never lose a transaction.
Engineering Challenges
cdc-axon
Change Data Capture SDK for PostgreSQL and MongoDB
┌─────────────────┐
│ PostgreSQL │
│ ┌─────────┐ │
│ │ WAL │───┼──────┐
│ └─────────┘ │ │
└─────────────────┘ │
▼
┌─────────────────┐
│ CDC-Axon │
│ ┌───────────┐ │
│ │ Outbox │ │
│ └─────┬─────┘ │
│ │ │
│ ┌─────▼─────┐ │
│ │ Delivery │ │
│ └─────┬─────┘ │
└────────┼────────┘
│
┌──────────────────┼──────────────────┐
│ │ │
▼ ▼ ▼
┌────────────┐ ┌────────────┐ ┌────────────┐
│ Kafka │ │ RabbitMQ │ │ Custom │
└────────────┘ └────────────┘ └────────────┘WAL-based CDC with pluggable brokers
Production-grade Go SDK for Change Data Capture. Taps directly into PostgreSQL's Write-Ahead Log and MongoDB's change streams, relaying outbox events to any message broker with at-least-once delivery, crash recovery, and pluggable persistence.
Engineering Challenges
goRabbit-axon
Production-ready RabbitMQ client with resilience patterns
Production-ready RabbitMQ Go client with connection pooling, exponential backoff, quorum queue support, publisher confirms, and graceful shutdown.
zodex-axon
Type-safe Express validation with compile-time guarantees
Express middleware that makes unvalidated request access a compile-time error. Zod + branded types strip req.body/params/query after validation and replace them with typed, validated data.
Other Projects
Explorations, utilities, and learning projects
rabbit-axon
TypeScript RabbitMQ scaffold with resilience patterns
redis-axon
Redis resilience layer with circuit breakers and pooling
gql-axon
GraphQL middleware orchestration with type inference
wire-axon
Type-safe HTTP client for React applications
future-executor-rust-pseudo
Pseudo implementation of async runtime in Rust
semaphore-simulation
Weighted semaphore implementation using sync.Cond
go-bloom-axon
Bloom filter implementation with murmur hash
Bastion-Host-Infra-Terra
Bastion host infrastructure with Terraform
Request Lifecycle
From Application to Infrastructure
Tracing a request through the complete stack—from application code through kernel, network, AWS edge services, VPC, and into distributed infrastructure.
CLIENT
NETWORK
AWS EDGE
VPC
INFRA
Technical Stack
Technologies organized by engineering domain. Not a list of buzzwords—these are tools I've used to build real systems.
Languages
Backend
Systems Internals
Data
Distributed Systems
Cloud & Infrastructure
Systems Understanding
Deep Knowledge
Not just APIs and frameworks. Understanding systems from application layer down to kernel, network, and hardware.
Networking & Protocols
OSI layers, TCP/IP, DNS hierarchy, BGP routing, kernel network stack
Security & Cryptography
TLS handshakes, PKI, certificate chains, symmetric & asymmetric encryption
Async & Concurrency
Tokio internals, epoll/kqueue, reactor pattern, futures, work-stealing
Infrastructure
Load balancing, TLS termination, VPC design, auto scaling patterns
"The kernel knows when I/O can make progress; the Reactor observes that readiness; the Executor schedules that computation; and the Future's poll() advances its state machine."
— Understanding async from first principles
How I Approach Systems
Engineering principles that guide how I think about building reliable, scalable systems.
Understand the failure modes
Don't only ask how the happy path works. Ask what happens when the network fails, a dependency times out, a process crashes, a message is duplicated, or a response arrives late.
Understand the abstraction boundary
Don't stop at "Go gives me a network connection." Ask: What happens inside the kernel? Where is the socket stored? How does epoll notify the application? How does the packet reach the NIC?
Design for scale
Ask: What becomes the bottleneck? What becomes stateful? What can be horizontally scaled? Where is coordination required? Where does backpressure occur?
In practice: When building the Saga orchestrator, I didn't just implement the happy path. I asked: What if the orchestrator crashes after sending a payment request but before recording the response? What if a timeout fires but the service actually succeeded? These questions shaped the entire architecture—CQRS event log for crash recovery, split idempotency for duplicate handling, and timeout monitoring with late-success reconciliation.
Deep Dives
Topics I've studied in depth—not surface-level overviews, but understanding how things actually work underneath the abstractions.
Distributed Systems
Saga Orchestration
Systems
Kernel Networking
Networking
DNS Resolution
Security
TLS Handshake
Async I/O
Tokio Internals
Networking
BGP Routing
Infrastructure
Load Balancing
Systems
epoll/kqueue
Distributed Systems
Saga Orchestration
Systems
Kernel Networking
Networking
DNS Resolution
Security
TLS Handshake
Async I/O
Tokio Internals
Networking
BGP Routing
Infrastructure
Load Balancing
Systems
epoll/kqueue
Documented in personal notes · Applied in projects
About
I like understanding systems from the outside-in and inside-out—from cloud infrastructure and networking down to sockets, concurrency and kernel behavior.
I'm particularly interested in understanding why systems fail, how they recover, how concurrency behaves under load, how data moves through distributed services, and how infrastructure decisions affect application behavior.
My approach is to dig deeper than the API surface. When I use a tool, I want to understand what it's doing underneath—not because I need to reimplement it, but because understanding the internals helps me use it correctly and debug it when things go wrong.
What I think about
- →Why systems fail and how they recover
- →How distributed services coordinate
- →How concurrency behaves under contention
- →How data moves through a system
- →How infrastructure affects applications
What I build
- →Distributed transaction orchestrators
- →Message queue clients with resilience
- →Change data capture systems
- →Type-safe middleware frameworks
- →Infrastructure automation
Resume
Summary of technical background and experience
Backend Engineering
Go, Node.js, TypeScript, Rust — Building APIs, microservices, and distributed systems with focus on reliability and performance.
Infrastructure
AWS, Terraform, Docker — VPC design, IAM, Auto Scaling, RDS, DynamoDB, and infrastructure as code.
Systems
Concurrency, networking, TCP/IP, sockets, kernel concepts — Understanding systems at multiple abstraction levels.
Distributed Systems
Kafka, RabbitMQ, CQRS, Saga pattern, event sourcing, CDC — Building fault-tolerant distributed architectures.
Notable Projects
DAG-based saga orchestration engine with CQRS recovery
Change Data Capture SDK for PostgreSQL WAL and MongoDB
Production RabbitMQ client with resilience patterns
Type-safe Express validation with compile-time guarantees