About

DevOps and infrastructure architect, network engineer and full-stack developer in Rangpur, Bangladesh.

04 About

Architect first, engineer all the way down.

Portrait of Miftahul Jony
Miftahul Jony
DevOps · Networks · Systems

I'm a Principal DevOps & Infrastructure Architect and full-stack engineer. I design systems end to end, from the network edge and infrastructure up through APIs, data and the interface people touch.

Success isn't measured by how much code gets written. It's measured by the most effective, reliable and well-reasoned answer to the real business objective. I break big problems into components, weigh the trade-offs, plan for failure modes and operational load, and ship systems that survive code review, production traffic and years of growth.

Most of my work serves real users in Bangladesh: patients reaching a doctor from their upazila, merchants taking mobile-money payments, shop owners keeping their accounts. That means designing for ordinary mobile data, two languages and systems that have to be right the first time.

  • System design

    Scalable, fault-tolerant architectures with clear boundaries and explicit trade-offs.

    • Clear boundaries
    • Fault tolerance
    • Data modelling

  • Network engineering

    DNS, TLS, routing, load balancing and edge networks that stay fast and secure.

    • DNS & TLS
    • Routing
    • Load balancing

  • DevOps & infrastructure

    CI/CD, containers, edge and cloud deployments, zero-downtime releases.

    • CI/CD pipelines
    • Containers
    • Zero-downtime releases

  • Reliability & security

    Observability, idempotency, retries, least privilege and audit trails by default.

    • Observability
    • Retries & idempotency
    • Least privilege
Based in
Rangpur, Bangladesh
Role
DevOps & infrastructure architect
Domains
Healthcare, SaaS & fintech
Status
Open to opportunities

05 System design & networking

Designing systems that scale and stay up.

How I think about architecture, from the packet at the edge to the event in the database.

Architecture Payment confirmation pipeline: the flow MJPay runs, from checkout to signed webhook
Payment confirmation system architecture Clients reach an edge layer with DNS, TLS, WAF and CDN, then an API layer with hosted checkout, a REST API and authentication. Core services match receipts, score risk and orchestrate payouts, backed by a database and an append-only audit log. An SMS bridge ingests operator receipts; a webhook dispatcher with retries notifies merchant servers; health checks feed a public status page. Clients Edge network API layer Core services Data & delivery Hosted checkoutcustomer phone Merchant serverREST + webhooks Merchant portal2FA · roles SMS bridgeagent phone DNS · Anycastglobal edge TLS 1.3 · WAFDDoS · rate limits CDN · cachestatic at the edge Checkout servicesession · wallet no. REST API /v1idempotency keys Auth & API keysHMAC · IP-locked Receipt matcheramount · number · TrxID Risk scoringlimits · new payees Payout orchestratorUSSD automation Primary databasepayments · merchants Append-only audit logevery staff action Webhook dispatchersigned · retry w/ backoff Health · public status receipt SMS signed webhook → merchant · ~8 s end to end

Network engineering, layer by layer

  1. L7

    Application

    HTTP/1.1, HTTP/2 & HTTP/3, REST, WebSockets, WebRTC, API gateways, reverse proxies (Nginx)

  2. L6

    Security & encryption

    TLS 1.3, certificate automation, mTLS, HMAC signing, WAF rules, zero-trust access

  3. DNS

    Naming & edge

    Authoritative DNS, Anycast, CDN caching, DDoS protection, geo-routing

  4. L4

    Transport

    TCP / UDP tuning, L4 load balancing, NAT, connection pooling, health checks

  5. L3

    Network

    IP routing, subnetting & CIDR, VPC design, VPN (WireGuard / IPsec), firewalls

  6. L2

    Data link

    VLANs, switching, segmentation of office, clinic and server networks

System design toolbox

  • ScalabilityStateless services, horizontal scaling, sharding and read replicas
  • CachingEdge, application and database caches with explicit invalidation
  • Async & eventsQueues, event-driven workflows, retries with exponential backoff
  • CorrectnessIdempotency keys, exactly-once effects, reconciliation jobs
  • ResilienceTimeouts, circuit breakers, graceful degradation, escalation paths
  • Traffic controlRate limiting, load shedding, backpressure
  • ObservabilityStructured logs, metrics, health endpoints, SLOs and public status
  • DeliveryBlue-green and canary releases, zero-downtime migrations, rollbacks
  • DataSchema design, transactions, backups and disaster recovery
  • Trade-offsConsistency vs availability, latency vs cost, documented as ADRs

06 Skills

The full stack, from packets to pixels.

System design & architecture

Distributed, event-driven systems designed around failure modes, data correctness and growth, with trade-offs made explicit.

  • Distributed systems
  • Microservices
  • Event-driven
  • Message queues
  • Caching
  • Idempotency
  • High availability
  • API design
  • ADRs

Network engineering

Secure, fast and observable networks, from DNS and TLS at the edge to routing and segmentation inside.

  • TCP/IP
  • DNS
  • TLS / mTLS
  • HTTP/2 & 3
  • Load balancing
  • Subnetting / CIDR
  • VLAN
  • VPN
  • Firewalls
  • CDN & WAF
  • Nginx

DevOps & infrastructure

Automated pipelines, containers and edge deployments, so releases are uneventful and rollbacks take seconds.

  • Linux
  • Docker
  • CI/CD
  • GitHub Actions
  • Cloudflare Workers
  • Infrastructure as code
  • Bash
  • Git

Reliability & observability

Health checks, SLOs, structured logs, alerting and public status pages.

  • Monitoring
  • Logging
  • SLOs
  • Incident response

Security

Secure by default, with least privilege everywhere.

  • 2FA
  • HMAC
  • RBAC
  • Audit logs
  • Secrets mgmt

Back-end & data

APIs, auth and data models that are easy to reason about.

  • Node.js
  • Express
  • Python
  • SQL / NoSQL
  • REST

Front-end

Fast, accessible, bilingual interfaces and dashboards.

  • React
  • Next.js
  • Vite
  • TypeScript / JS

Payments & real-time

Mobile-money rails, webhooks, payouts and live video.

  • bKash / Nagad
  • Webhooks
  • WebRTC

AI & automation

Role-aware assistants, LLM agents, tool calling and memory.

  • LLM agents
  • Tool calling
  • Cloudflare AI

07 Engineering principles

Built to withstand production.

  1. 01

    Understand before acting

    Read the whole problem, pull out the explicit and implicit requirements, and gather context before touching code. No assumptions left unexamined.

  2. 02

    Weigh trade-offs first

    Break complex work into components and compare approaches before building. Choose the design that holds up, not the one that's quickest to type.

  3. 03

    Design for failure

    Anticipate failure modes and operational load: retries with backoff, idempotency, escalation paths, public status and health checks.

  4. 04

    Reuse over duplication

    Prefer shared abstractions and clear boundaries, so systems stay maintainable as teams and features grow.

  5. 05

    Secure by default

    Signed webhooks, two-factor auth, IP-locked keys, role-based access and append-only audit trails. Least privilege everywhere.

  6. 06

    Verify, don't assume

    Run it, test it and check it live. Report outcomes honestly, then make the small adjacent improvements that clearly add value.

Ready to start?

Send a short brief and get a plan and quote, usually within a day.

Book a service