Md Mofijur Rahman
I am a backend engineer specializing in building scalable microservices, gRPC-based distributed systems, and high-performance APIs using Golang, Node.js, PostgreSQL, and Redis.

Engineering at the intersection of
scale & performance
I'm Md Mofijur Rahman (Ahmad), a backend-focused Golang & Node.js engineer with nearly 4.5 years of professional software engineering experience and 5+ years of full-stack development expertise.
I specialize in designing decoupled microservices, gRPC-based service communication, and event-driven architectures using Golang, Node.js, PostgreSQL, and Redis. I am adept at delivering clean, maintainable, production-grade code optimized for concurrency and system-level performance.
My experience spans architecting decoupled microservices for high-traffic e-commerce and OTA platforms, to designing high-performance backend systems with advanced caching, concurrency, and clean architecture (DDD).
Experience
Core Proficiencies
Tools of the trade
A curated selection of technologies I use to build reliable, high-performance systems.
Languages
Go Ecosystem
Databases & Caching
Architecture & Messaging
DevOps & Infrastructure
Frontend UI
Things I've built
Distributed microservices, scalable backend systems, and OTA platforms.
CartUp (E-Commerce)
Engineered decoupled Go microservices for core Product, Order, and Customer domains, using gRPC for type-safe inter-service communication and Kafka for event-driven, asynchronous workflows — built for horizontal scalability.
FirstTrip & SkyTrip
Contributed to massive travel booking architectures, optimizing query execution and elevating front-end performance for a smooth user experience. Managed complex hotel and holiday booking modules.
High-Performance Backend System
Designed a multi-tier Redis caching layer and optimized PostgreSQL access patterns for a high-throughput backend, cutting API latency to sub-millisecond ranges while preserving strict ACID transactional guarantees under heavy concurrent load.
Distributed Order Microservice
Engineering scalable backend systems for high-traffic platforms. This showcase demonstrates a distributed order-processing microservice built with Golang, gRPC, and Kafka — designed for horizontal scalability and resilient, event-driven communication between services.
Order requests arrive via gRPC from upstream services (Product, Customer) using protobuf-defined contracts for type-safe, versioned communication.
Incoming orders are validated against business rules. Logic is optimized for concurrency using Go-routines and channels to ensure non-blocking execution.
Data is persisted to PostgreSQL using sqlc for type-safe, high-performance queries. Schemas are optimized with indexing for fast operational access.
Order events are published to Kafka topics, decoupling the Order service from downstream consumers like Inventory, Billing, and Notification services.
Order state is cached in Redis for sub-millisecond reads, while downstream microservices stay in sync via gRPC calls with retries and graceful degradation.
// Distributed order microservice (Golang + gRPC)func (s *OrderService) CreateOrder(ctx context.Context, req *pb.CreateOrderRequest) (*pb.OrderResponse, error) { // 1. Validate the incoming gRPC request payload if err := s.validator.Validate(req); err != nil { return nil, status.Errorf(codes.InvalidArgument, "invalid order: %v", err) } // 2. Persist to PostgreSQL via sqlc for type-safe, low-latency writes order, err := s.queries.CreateOrder(ctx, db.CreateOrderParams{ ProductID: req.ProductId, CustomerID: req.CustomerId, Quantity: req.Quantity, Price: req.Price, }) // 3. Publish "order.created" to Kafka for async downstream services payload, _ := json.Marshal(order) err = s.kafkaWriter.WriteMessages(ctx, kafka.Message{ Key: []byte(order.ID.String()), Value: payload, }) // 4. Cache order state in Redis for fast, repeated reads s.redis.Set(ctx, fmt.Sprintf("order:%s", order.ID), payload, time.Hour) return &pb.OrderResponse{ OrderId: order.ID.String(), Status: "ACCEPTED", }, nil}Let's build something remarkable
Whether you're looking to hire a Golang/Node.js backend engineer, collaborate on microservices & gRPC architecture, or talk through a system design problem — my inbox is always open.