AVAILABLE FOR OPPORTUNITIES

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.

Md Mofijur Rahman
4+
Professional Years
📦
5+
Full-stack Experience
☁️
Go·SQL·Redis
Core Stack
🛠️
10+
Systems Built
scroll

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).

Backend Engineering
Golang · Node.js (NestJS/Express) · TypeScript · SQL · HTML/CSS
Go Ecosystem
Gin · Chi · Fiber · GORM · sqlc · SQLx · Go-routines · Channels
Databases & Messaging
PostgreSQL · Redis · Microservices · gRPC · Kafka · RabbitMQ
DevOps & Frontend
Docker · CI/CD · Nginx · Linux (Ubuntu) · React · Next.js · React Native

Experience

2023–Present
Software Engineer
TechnoNext Limited
Building scalable microservice-based systems for Cartup e-commerce platform and FirstTrip (OTA) covering hotel, tour, and travel booking services.
2022–2023
Software Developer
BDTask Limited
Engineered Go/PostgreSQL backend services with multi-tier Redis caching, cutting API latency to sub-millisecond ranges while preserving strict ACID transactional integrity.
2022–2022
Full-Stack Developer
Shara IT
Designed Madrasha Management System using Node.js (NestJS), PostgreSQL, and React Native.

Core Proficiencies

Golang / Microservices95%
SQL / PostgreSQL / Redis92%
gRPC / Kafka / Messaging88%
System Design / Performance90%

Tools of the trade

A curated selection of technologies I use to build reliable, high-performance systems.

⌨️

Languages

GolangNode.js (NestJS/Express)TypeScriptJavaScriptSQLHTML/CSS
🐹

Go Ecosystem

GinChiFiberGORMsqlcSQLxGo-routinesChannels
🗄️

Databases & Caching

PostgreSQLRedisMySQL
🔗

Architecture & Messaging

MicroservicesgRPCKafkaRabbitMQEvent-Driven ArchitectureDDD
☁️

DevOps & Infrastructure

DockerCI/CDNginxLinux (Ubuntu)Git
🖼️

Frontend UI

ReactNext.jsReact Native

Things I've built

Distributed microservices, scalable backend systems, and OTA platforms.

Featured
🛒

CartUp (E-Commerce)

Distributed Microservices Architecture

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.

✓ gRPC + Event-Driven Microservices
GolangMicroservicesgRPCKafkaPostgreSQLDocker
✈️

FirstTrip & SkyTrip

Online Travel Agency (OTA) Platforms

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-traffic OTA systems
GolanggRPCKafkaReact.jsRedisSystem Performance

High-Performance Backend System

System Design — Caching & Concurrency at Scale

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.

✓ Sub-millisecond API latency
GolangSystem DesignRedis CachingPostgreSQLConcurrencyPerformance Tuning

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.

Microservice Request Flow
📡
01
gRPC API Layer

Order requests arrive via gRPC from upstream services (Product, Customer) using protobuf-defined contracts for type-safe, versioned communication.

gRPCProtobufType-Safe APIsService Contracts
⚙️
02
Validation & Business Logic

Incoming orders are validated against business rules. Logic is optimized for concurrency using Go-routines and channels to ensure non-blocking execution.

Go-routinesChannelsConcurrencyValidation
🗄️
03
High-Performance Persistence

Data is persisted to PostgreSQL using sqlc for type-safe, high-performance queries. Schemas are optimized with indexing for fast operational access.

PostgreSQLsqlcDatabase IndexingType-Safe SQL
🔗
04
Event-Driven Messaging (Kafka)

Order events are published to Kafka topics, decoupling the Order service from downstream consumers like Inventory, Billing, and Notification services.

KafkaEvent-DrivenMicroservicesDecoupling
🚀
05
Caching & Service Sync

Order state is cached in Redis for sub-millisecond reads, while downstream microservices stay in sync via gRPC calls with retries and graceful degradation.

RedisgRPCResilienceMicroservices
order_service.goGOLANG
// 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
}
Low-Latency Execution
Optimized for millisecond-level response times using Go's efficient runtime and concurrency model.
🔁
Event-Driven Scale
Kafka-based architecture allows for horizontal scaling and reliable message delivery across services.
🌐
Type-Safe gRPC Contracts
Protobuf-defined gRPC services ensure type-safe, versioned communication across microservice boundaries.

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.