Skip to content

Domain-Driven Design.
Distributed Systems.
Event-Driven Architecture.

Open to new opportunities.

About

Hi, I'm Tawsif. I design systems where domain boundaries are intentional, not accidental. Bounded contexts that align with business capabilities. Event flows that preserve causality. Service interfaces that don't leak internal details. Over a decade across Europe and Asia, moving between IC and engineering manager roles — building systems where reliability, observability, and fault-tolerance are first-class concerns, not afterthoughts.

I specialize in legacy-to-greenfield migrations: extracting domain cores from tangled monoliths, replatforming with SOLID principles, and decomposing into well-bounded services — whether microservices or a modular monolith, greenfield or brownfield. I wire services together with event-driven architectures that provide strong consistency guarantees, and design internal APIs meant to be consumed by other engineers for years to come.

Currently at Mollie in the Netherlands, building their Capital product. Before this: engineering manager at Sendcloud, senior engineer at HelloFresh in Berlin, and a few more interesting chapters across startups and scale-ups in Bangladesh and the Netherlands.

Systems I've Designed

Domains where I've made hard architectural decisions in production — not tutorials, not side projects. Real distributed systems handling real money, real logistics, real traffic, with the reliability and observability that demands.

Payment Infrastructure
Ledger design with event sourcing, reconciliation engines as domain services, compliance boundaries as bounded contexts. Making money move without losing track of it — with full audit trails, idempotency, and fault-tolerant processing.
Supply Chain & Logistics
Event-driven order pipelines, CQRS for real-time tracking views, domain events for cross-bounded-context coordination. When "it's on the way" has to actually mean something — eventually consistent but never wrong.
Internal APIs & Platform
Versioned internal APIs, developer tooling, platform services designed with SOLID principles. The shared infrastructure that keeps a growing organization from drowning in its own complexity — designed for evolution, not just execution.
Legacy to Greenfield Migration
Extracting domain cores from legacy monoliths, defining bounded contexts from existing business logic, replatforming onto event-driven architectures. The careful, deliberate work of turning years of accumulated complexity into clean, observable, fault-tolerant services.

Architecture in Practice

Architectural decisions aren't abstract preferences — they're responses to real constraints. These are problems I've faced and the reasoning behind what I chose.

Observability That Caught What Tests Missed
A payment infrastructure service passed every integration test but silently dropped requests/events during exception. Added structured logging, distributed tracing across services, and alerting on domain invariants. The next edge case surfaced in minutes, not days.
Domain-Driven Design in a Logistics Platform
A logistics platform with billing, tracking, and tired subscription logic tangled across shared modules. Identified domain seams through ubiquitous language sessions with the team, then extracted each bounded context behind an anti-corruption layer — zero downtime, incremental cutover.
Event-Driven Architecture for Supply Chain Management
A supply chain management system where data pipelines and service communication were tightly coupled. Introduced domain events to decouple services, built asynchronous data pipelines with strong consistency guarantees, and replaced polling with event-driven flows. Throughput improved, coupling dropped.
Legacy Monolith to Bounded Context Microservices
A ride-sharing platform with an older monolith where dispatch, pricing, and driver management shared the same database and deployment cycle. Extracted bounded contexts one at a time — each with its own schema and deployment — using a strangler fig pattern. No big bang, incremental rewrite.
Breaking APIs Without Breaking Consumers
Internal APIs across multiple verticals — food delivery, last-mile logistics, ride-sharing. Introduced contract-first design with versioned endpoints, backward-compatible deprecation paths, and SOLID-inspired module boundaries. New teams started onboarding without talking to anyone.

Tech Stack

Languages

Go

PHP

Python

Elixir

TypeScript

Frameworks

Symfony

Laravel

FastAPI

React

Next.js

Data & Messaging

PostgreSQL

MySQL

RabbitMQ

Kafka

Redis

Architecture & Design

Domain-Driven Design

Event-Driven Architecture

Event Sourcing & CQRS

SOLID Principles

Microservices & Modular Monolith

Reliability & Observability

Datadog

Grafana

Prometheus

Sentry

Graylog

Infrastructure

Docker

Kubernetes

Helm

AWS

NixOS