Practitioner-first Senior Software Architect / Senior Software Engineer with 10+ years of experience specializing in high-throughput FinTech infrastructure, payment gateway integration, and cloud-native distributed systems. Grounded in physics training (M.S. in Physics, NTNU), I bring a first-principles, mechanical-sympathy approach to designing resilient backend systems, secure transaction flows (ISO 8583, PCI-DSS), and scalable cloud infrastructure (GCP, AWS, Azure).

• 🔭 Currently working on: Enterprise payment gateway architectures (OmniSwitch), cross-platform security SDKs (Aegis-Scan), and air-gapped AI-assisted quality inspection systems (WaferSight).
• 💡 Core Expertise: Distributed Systems, Domain-Driven Design (DDD), Hexagonal & Modular Monolith Architectures, High-Throughput Payment Engines, and Resilient Cloud-Native Infrastructure.
• 🛠️ Tech Stack: C# (.NET), Python (FastAPI), TypeScript (Node.js, NestJS), Go, C++20, PostgreSQL, Redis, Kubernetes, Terraform, GCP, AWS, Azure.
• 📫 Let's Connect: LinkedIn (Da-Wei Lin)

• Design for Failure: Systems must degrade gracefully. Centralized orchestration often creates bottlenecks; I favor resilient, decoupled boundaries.
• Documentation is Architecture: Clear technical documentation and standardized protocols (like PCI DSS or ISO 8583) are non-negotiable for system integrity.

• API

  • Smile Rabbit Bear - AI Translation API

• CLI

  • Aegis-NetValid-Core [The Orchestrator] [Latest]

• Core Function: A from-scratch reference implementation of a payment gateway that sits between merchants and card networks. It handles smart multi-PSP routing (Stripe + Adyen, BIN-aware) and absorbs complex money-movement edge cases like refunds, disputes, retries, and payouts.
• Key Insight: Demonstrates how enterprise payment patterns fit together end-to-end. It features a real double-entry ledger, subscriptions with decline-aware dunning, marketplace splits with connected-account payouts, risk-based reserves, and delegated "agentic payment" credentials.
• Tech Stack: NestJS, TypeScript, Hexagonal Architecture, Domain-Driven Design (DDD), PostgreSQL (Master/Replica CQRS), Redis, HashiCorp Vault.
• Note: This is a portfolio/reference project built to showcase real, verified infrastructure integration (not just mocked-out unit tests). Please review the Known Limitations and LICENSE before assuming any part of it is production-ready.

• Core Function: A cross-platform, zero-disk, low-latency scanning engine for payment cards (PAN), ID documents (ICAO MRZ), and vouchers, built on a shared C++20 core with a stable C ABI.
• Key Insight: Prioritizes strict data privacy through a "zero-disk" architecture and memory-wipeable buffers for sensitive PAN data. It maintains high performance using atomic frame dropping (processing a single in-flight frame) and applies a unified OCR-confusion repair algorithm universally across mobile, web, and desktop environments.
• Tech Stack: C++20 (Core Engine), Swift / AVFoundation (iOS), Kotlin / ML Kit (Android), TypeScript / Web Workers (Web), .NET 8, Java 21+ (FFM/JNI).
• Note: The React Native and Flutter implementations are provided as working reference wrappers rather than published packages. Web-based scanning requires a pluggable external OCR module (like Tesseract.js), and live camera accuracy scales with the platform's native recognizer capabilities.

• Core Function: An end-to-end machine learning inference API that evaluates transactional risk and predicts credit card fraud in real time, trained on the IEEE-CIS Fraud Detection competition dataset.
• Key Insight: Built with production-grade rigor rather than stopping at a notebook metric. It utilizes a strict time-based split (earliest 80% train, latest 20% validation) to prevent data leakage from temporal concept drift, achieving a realistic PR-AUC of 0.5926 (with 3.5% base fraud rate). It features a mostly-named request schema reflecting real payment fields (product_cd, card networks, email domains, address metrics) alongside anonymized vendor feature arrays, and enforces bulletproof preprocessing consistency where incoming live requests are mapped using the exact same training-fit OrdinalEncoder (handling missing None values into true NaNs) to prevent silent model degradation.
• Tech Stack: Python, Pandas, NumPy, Scikit-Learn, LightGBM, FastAPI, Uvicorn, Joblib
• Note: The underlying LightGBM model and encoder are pre-trained and committed for instant API deployment, but the raw IEEE-CIS dataset (~1.3GB) must be downloaded separately from Kaggle if you wish to rerun train.ipynb from scratch.

• Core Function: A local-first desktop application enabling fab quality engineers to perform interactive 3D wafer visualization, offline AI defect classification, and statistical process control (SPC) monitoring directly on-device.
• Key Insight: Designed for air-gapped or high-security fab environments, the architecture completely eliminates external API dependencies. By leveraging onnxruntime-web for 100% local inference and implementing a background human-in-the-loop calibration layer, the system continuously adapts to engineer feedback without modifying the base CNN weights—solving model drift while maintaining deterministic reliability.
• Tech Stack: Electron, React 19, TypeScript, Node.js, SQLite (Encrypted at rest), ONNX Runtime, Three.js
• Note: The underlying CNN classifier was trained offline via PyTorch on the WM-811K dataset (achieving 95.6% accuracy). The application enforces strict IPC boundaries between the renderer and main processes to ensure robust local security.

I develop specialized Digital Tools designed to validate, stress-test, and monitor wireless networking infrastructure. These tools bridge the gap between raw data collection and actionable QA insights.

• Core Function: A unified, multi-engine validation framework that orchestrates the entire suite (Simulator, Stresser, IDS, Monitor) into a single testing workflow.
• Key Insight: Solves the "Fragmentation" problem in network QA by providing time-synced data aggregation and engine lifecycle management. It allows for complex scenarios, such as: “Trigger 100 devices (Simulator) -> Inject 95% load (Stresser) -> Validate if IDS detects the resulting anomalies in real-time.”
• Tech Stack: Python (Multiprocessing), YAML-driven Scenarios, Rich (TUI Dashboard), Cloud-native validation (AWS/GCP IoT SDKs).

• Core Function: A high-fidelity framework that emulates 50+ diverse IoT devices (IP Cameras, Smart Bulbs) with dynamic behaviors and security vulnerabilities.
• Key Insight: Validates Router Stability and Security Observability by simulating real-world chaos like "Thundering Herd" reconnection and anomaly injection.
• Tech Stack: Python, Threading, Rich (Dashboard), Zeroconf (mDNS), Scapy.

• Core Function: Tracks RSSI (Signal Strength), Noise Floor, and Latency over time.
• Key Insight: Helps identify signal degradation patterns and interference in Mesh environments.
• Tech Stack: Python, CoreWLAN (macOS), Pandas.

• Core Function: Simulates high-density household traffic using multi-threaded iperf3 streams.
• Key Insight: Evaluates Bufferbloat, Congestion Control, and hardware stability under 95%+ load.
• Tech Stack: Python, Subprocess, Matplotlib, JSON-parsing.

• Core Function: A modular Intrusion Detection System (IDS) that monitors real-time IoT traffic to identify and mitigate cyber threats (DDoS, Scanning, Lateral Movement).
• Key Insight: Implements Stateful Traffic Profiling and Sliding-Window Frequency Analysis to distinguish between normal device heartbeats and malicious spikes.
• Tech Stack: Python, Scapy (Packet Inspection), PyYAML (Config-driven), psutil (System Guard), Logging.

My toolkit addresses the full spectrum of network validation:

1. Signal Layer: WiFi-Performance-Monitor (RF Health)
2. Throughput Layer: Network-Stresser (Capacity & Stress)
3. Application/IoT Layer: Smart-Home-Simulator (Ecosystem Behavior & Security)

A collection of production-ready NestJS templates following modern software architecture principles.

• Onion architecture with DDD
• Microkernel (Plug-in) architecture
• Clean Architecture
• Hexagonal Architecture
• Modular Monlith Architecture

• Modular Monolith Architecture with integrated CQRS and Event Sourcing patterns
• Modular Monolith Architecture incorporating Event-Driven communication patterns

• Clean Architecture
• Modular Monolith Architecture
• Hexagonal Architecture

Waiting....

Waiting....

• Onion architecture with DDD
• Modular Monolith Architecture
• Microkernel (Plug-in) architecture [Latest]