Akshay Gudhate
I design and build the kind of infrastructure that quietly makes everything else work — real-time messaging systems, event-driven pipelines, and multi-tenant platforms that scale without drama. Currently re-architecting distributed systems at Three Matter Labs using Go, PostgreSQL and NATS.
Over 8 years, I've operated at the intersection of distributed systems design and hands-on engineering — the kind of work that requires both whiteboard clarity and production-grade execution. My deepest experience is building high-throughput, event-driven platforms from scratch: defining the architecture, making the hard trade-offs, and then actually shipping it.
At Biz Secure Labs, I led the ground-up development of Bitamin, a real-time messaging and workflow automation platform handling multi-channel communication (WhatsApp, Instagram) and third-party integrations at scale. That work shaped how I think about system design: complexity should live in the infrastructure, not the application layer.
I love exploring new things, from computer vision to AI-assisted development.
What I bring to a Staff+ role
System Design & Architecture
Designing for scale before the scale arrives. Event-driven, async-first, loosely-coupled — I've learned these principles the hard way and apply them early.
Technical Leadership
Driving architectural decisions, aligning engineering teams on direction, and translating ambiguous product goals into concrete system design.
Platform Migration
Led Node.js → Go and RabbitMQ → NATS migrations in production — understanding the cost, risk, and timing of when to rewrite vs. refactor.
Integration Engineering
Built a pluggable integration framework (Zoho, IndiaMART, Razorpay) that lets new third-party connectors ship without touching core messaging logic.
Multi-Tenant Architecture
Designed logical tenant isolation, per-tenant workflow configuration, and scalable data handling patterns used by concurrent enterprise customers.
Reliability Engineering
Async job processing with retry semantics, failure isolation between integrations, and database optimization via indexing and materialized views.
Bitamin Platform Architecture
Real-time messaging and workflow automation platform. Designed to handle concurrent, multi-channel event streams with full workflow orchestration.
Node.js → Golang
Node.js handled early product velocity well, but goroutines gave us true concurrency for high-throughput workloads — particularly processing thousands of simultaneous webhook events without the event loop becoming a bottleneck. The switch also eliminated an entire class of callback-complexity bugs.
RabbitMQ → NATS
RabbitMQ's exchange/binding model added operational surface area with limited upside for our use case. NATS gave us lower latency, a simpler topology, and drastically reduced operational overhead — no broker management, no complex routing configuration to maintain.
Integration Adapter Pattern
Wrote the first three integrations directly against core messaging logic — a mistake I corrected quickly. Built a typed adapter interface so all third-party connectors are isolated behind a contract. New integrations now ship without modifying the workflow engine at all, and failures in one adapter cannot cascade.
gRPC for Internal Services
REST over HTTP/1.1 was adding latency on the hot path between internal services. gRPC with protobuf contracts gave us typed interfaces, lower serialization overhead, and bi-directional streaming support for real-time analytics pipelines currently in development.
Career History
- Leading full re-architecture of messaging infrastructure from Node.js + RabbitMQ to Go + NATS, improving concurrency characteristics and reducing operational surface area.
- Defining gRPC service contracts across the platform, enabling typed, low-latency internal communication and paving the way for real-time analytics.
- Driving technical roadmap for high-availability topology, including distributed consumer groups and graceful failover strategies under load.
- Establishing engineering standards — code review process, service design principles, and on-call runbooks for production readiness.
- Built Bitamin from scratch: designed the data model, service topology, event bus integration, and worker processing pipeline — 0 to production in under 6 months.
- Introduced event-driven architecture early in the product's life, enabling async job processing that scaled to handle concurrent multi-tenant load without re-architecture.
- Shipped a pluggable integration framework that decoupled third-party adapters (Zoho CRM, IndiaMART, Razorpay) from core messaging logic — new integrations deployed in days, not weeks.
- Drove database performance improvements through query profiling, composite index design, and materialized views — reducing P95 query time on hot paths by significant margins.
- Mentored junior engineers on distributed systems concepts, code quality, and production ownership culture.
- Built RESTful APIs and background job systems across multiple Node.js-based products in fast-moving startup environments.
- Developed strong intuition for database schema design, caching strategy, and API contract stability — foundational skills that informed later architectural decisions.
- First exposure to message queue systems (RabbitMQ) and async processing patterns that became central to later platform work.
How I think about systems
Complexity belongs in infrastructure, not application code.
A well-designed event bus, adapter interface, or job queue absorbs complexity so that the services consuming them stay simple and focused. I design systems where the hard parts are clearly located.
Migrations are a product problem, not just a technical one.
Stack decisions have business consequences. I've led migrations by making the case — clearly — for what changes, what risk is involved, and what the team gets in return. Then executing incrementally.
The most important interface is the one between services.
Internal contracts (gRPC, event schemas, adapter interfaces) deserve more rigor than public APIs. They're harder to change and failures are less visible. I treat them as first-class design artifacts.
Scale the team's thinking, not just the system.
A staff engineer's highest leverage is making other engineers think more clearly about trade-offs, failure modes, and long-term cost. Documentation, design reviews, and code review culture matter.
Current Focus
At Three Matter Labs, I'm actively leading the Go, PostgreSQL, NATS re-architecture of our messaging infrastructure. On the design side, I'm formalizing our gRPC service contracts and working through the distributed consumer group topology for the next availability tier. Outside of work, I'm writing about event-driven design patterns on Medium and exploring real-time analytics pipelines with ClickHouse. I'm also exploring computer vision with OpenCV, LLM agents with LangChain and LangGraph, and AI-assisted development with Claude Code, Cursor and Zed.