01 — Identity
Delivering scalable enterprise backends and engineering high-throughput, fault-tolerant infrastructure in Rust. Mastered the Node.js / Next.js ecosystem to ship complex enterprise workflows and real-time applications — now deepening focus into systems engineering where performance and correctness are non-negotiable.
02 — Technical Arsenal
runtime · async I/OBuilt entirely in Rust to guarantee memory safety, absolute fault tolerance, and sub-millisecond routing decisions across multiple payment gateways. Asynchronous I/O is driven by the Tokio runtime — a work-stealing scheduler that fans thousands of concurrent gateway handshakes across a fixed thread pool without blocking.
// sub-ms gateway selection — zero allocations on hot path pub async fn route_intent(intent: &PaymentIntent) > Result<GatewayAck, RouterError> let gateway select_gateway(intent)await?; let ack gatewaydispatch(intent)await; match ack Ok(a) > Ok(a), Err(e) > compensate(intent, e)await, }Ownership and the borrow checker eliminate entire classes of use-after-free, double-free, and data-race bugs at compile time — no garbage-collection pauses on the hot path.
ownership · lifetimesIdempotent transaction intents, saga-style compensation, and deterministic retry budgets guarantee exactly-once semantics even across partial gateway failures.
idempotency · sagasThe Tokio runtime drives thousands of concurrent gateway handshakes on a single thread pool via non-blocking I/O and a multi-threaded work-stealing scheduler.
tokio · async-awaitA chronological record of real production impact — from enterprise workflow platforms to real-time auction backends, converging on high-performance systems engineering.
Independent R&D·Deep work
G3 Interactive·Kochi, IN
SpaceAI·Remote
Autobse·Kochi, IN
Self-assessed proficiency across the stack — calibrated against production shipped, not tutorial hours. Bars animate on scroll into view.
A six-month commit cadence across AutoGate, production systems, and exploratory Rust work. Intensity reflects commits per day — not lines, not LOC ego metrics.
Where each technology sits in my adoption lifecycle — from battle-tested daily drivers to research-stage curiosities. Hover any node for context, or filter by quadrant.
Inspector
Rings
A living snapshot of what I'm building, learning, and exploring — updated as the focus shifts. RSS feed
Rust + Tokio runtime — multi-gateway routing with saga-style compensation and idempotent intents.
Deep-diving ownership, lifetimes, and the borrow checker. Working through async runtime internals.
Investigating eBPF and XDP for programmable packet processing on the hot path.
Studifying leader-election, log replication, and partition tolerance for fault-tolerant clusters.
Excerpted endorsements from engineers, leads, and reviewers who shipped alongside me. Names abbreviated — full references available on request.
“Ihsanul shipped a multi-tenant NestJS backend under a tight deadline and the system held under production load without a single regression. Rare to find engineers who treat correctness as a first-class constraint.
“When we moved real-time visitor analytics to a socket layer, he owned the ingest path end-to-end. Latency dropped, dashboards went live, and the booking flow stayed idempotent under double-submit.
“The zero-knowledge WebSocket architecture on SecureTerminal was structurally blind to payload contents — exactly what we asked for. He thinks in threat models before writing a line of code.
“End-to-end typed contracts across the storefront and API layer meant schema changes surfaced as compile errors before they reached production. A maintainer's dream.
Short technical notes from the trenches — mental models, hard-won lessons, and the occasional rant about distributed systems. Click any note to read the full text.
The borrow checker isn't an adversary — it's a compile-time proof that your concurrent access is sound. Here's the mental model that finally made it click.
Distributed transactions across payment gateways can't rely on two-phase commit. Saga + idempotency keys is how you get exactly-once semantics without it.
Tokio's multi-threaded runtime isn't just 'threads plus async'. The work-stealing scheduler is what lets a single binary handle tens of thousands of concurrent connections.
A selection of shipped infrastructure and product work — from zero-knowledge messaging to AI-driven interview pipelines. Click any card for a deep dive.