Myo Thant Kyaw

Problem

A payment platform moving high transaction volume can't rely on manual review to catch money-laundering risk. Suspicious patterns — unusual amounts, velocity spikes, repeated structuring behavior — have to surface automatically, with every flagged transaction reviewable and traceable for compliance.

My role

Designed and built the monitoring system — detection rules, alert workflow, and integration into the transaction pipeline.

Rule-based detection engine

Threshold, velocity, and pattern rules evaluated against live transaction streams, so risk signals surface without anyone watching spreadsheets.

Screening off the hot path

Monitoring runs as an event-driven pipeline fed from the core transaction flow — screening adds no latency to payment processing.

Alert & review workflow

Flagged transactions route to a review queue for compliance operators, with full transaction context attached for decision and audit.

Problem

A unified payment platform spanning multiple channels — PayNow, Visa, and wallet integrations — where each provider brings its own API contracts, security requirements, and settlement behavior. Transaction volume demanded attention to processing latency and database performance.

My role

Senior Software Engineer — system architecture, database design, API integration. Led a remote team of 5 developers through the full lifecycle.

Concurrency & throughput

Improved transaction processing performance by 40% using Go channels, Redis, asynchronous processing, and database indexing — the core techniques I reach for when a hot path needs to scale.

Secure external integrations

Integrated multiple financial service APIs into a unified system, applying PGP/JWE encryption and signature verification for financial payloads.

Database performance

Designed database structures and indexing for transaction workloads, keeping query latency predictable as volume grows.

Problem

Cross-border payments flow through multiple external providers — long-running, failure-prone operations that cannot block a request path and must survive partial failures cleanly.

My role

Backend design and Golang implementation within a team I led.

Asynchronous workflows

Event-driven processing with RabbitMQ and asynchronous patterns, so slow provider operations never stall synchronous API paths.

Failure handling across providers

Cross-border processing integrates multiple providers with differing behaviors — designed for retries, webhook-based status delivery, and safe failure recovery.

Provider abstraction

Unified multiple provider APIs behind consistent internal boundaries, keeping provider-specific quirks out of core transaction logic.

Problem

Settlement monitoring and reconciliation were handled manually — slow, error-prone, and invisible until something went wrong. Operations needed tooling that watches the system instead of people watching spreadsheets.

My role

Designed and built internal tools as part of platform ownership.

Automation over manual process

Built automation tooling that reduced manual reconciliation work by 60%.

KYC processing pipeline

Internal tooling for customer onboarding (KYC) workflows, productionized at csonboard.mctpay.sg.

Problem

Legacy services accumulated the usual problems: tangled responsibilities, hard-to-test code, and scaling friction. The platform needed Go-based services without a big-bang rewrite.

My role

Led the migration — architecture decisions and incremental delivery with the team.

Incremental migration

Migrated components to a Golang-based architecture piece by piece, keeping production running throughout.

Test-first confidence

Unit testing built into the new services from the start, plus SAST gates (SonarQube) for code quality.