Systems Thinking | Software Engineer
Senior Software Engineer, 8+ yrs production systems.
Polyglot engineer C++, Go, and JS/TS. SQL and NoSQL (Postgres, ScyllaDB, Redis).
Pragmatic systems thinking approach to evaluate trade-offs while looking for performance,
reliability, and user experience. Unique blend of engineering and creative background enable effective
collaboration across technical and non-technical teams. Documents ADRs/RFCs and technical leadership
across multi-cloud environments.
AI-Powered Real-Time Audio Moderation System
• Engineered a Go-based gRPC server integrating whisper.cpp (GGML) models for on-device speech-to-text, ensuring low-latency processing without external API dependencies or data privacy risks.
• Designed a thread-safe worker pool pattern to manage non-thread-safe C++ AI libraries within Go, optimizing throughput while maintaining system stability under high load.
• Demonstrated a viable solution to reduce platform ban risks by ~90% through early keyword detection, translating complex ML capabilities into actionable business protection.
Watch Demo: https://youtu.be/IwSptYtNRzM
Source Code & Documentation: https://github.com/prothegee/server-backend-audio_transcriber-go
GameStore Frontend (Next.js 16 + Steam UI)
• Built a Steam-inspired game store with Next.js 16 App Router: hybrid SSR/client rendering, infinite scroll catalog (100+ games), i18n (en/id), and optimistic cart updates via server actions.
• Engineered secure server-first state: HTTP-only session cookies, signed cart persistence, and client-side validation — delivering responsive UX with 44ms+ TTI on localized routes.
• Validated with Vitest + Playwright E2E; documented via ADRs, HLD/LLD, and feature specs for scalable team development.
Source Code & Documentation: https://github.com/prothegee/gamestore-fe-store
GameStore ERP (Vue 3 + Internal Dashboard)
• Built a role-based internal ERP dashboard with Vue 3 (Composition API) covering 8 business modules — products, orders, customers, suppliers, promotions, media, reports, and staff accounts — with a mock-first localStorage layer and clear API integration points per module.
• Implemented client-side RBAC via Vue Router guards (4 roles: superadmin, manager, staff, viewer) and 8 Pinia stores following a load-seed-persist pattern, keeping the UI fully operational without a live backend.
• Delivered a complete frontend quality toolchain: ESLint 10 flat config + Prettier 3, 65 Vitest unit tests, and Playwright E2E — deployed as a static SPA via serve + PM2 behind HAProxy with SNI routing and deny-by-default for unmatched hosts.
Source Code & Documentation: https://github.com/prothegee/gamestore-fe-erp
Flutter Shop Case (Layered Mobile E-Commerce Architecture)
• Designed and implemented a production-ready Flutter shopping application with authentication, real-time search, cart management, and checkout flow — structured via layered architecture (Presentation → Providers → Services → Models).
• Engineered isolate-based background tasks for cache cleanup, analytics sync, and data prefetching without blocking the UI thread; persisted session state and theme preferences via SharedPreferences.
• Quantified modularity: 9 core services/providers, 5 main UI screens, 100% local feature coverage with clear backend integration points marked via NOTE:/TODO: annotations for seamless API adoption.
Source Code & Documentation: https://github.com/prothegee/flutter_shop_case
ZIX. A high-performance network backend library & http engine written in Zig.
• Designed & implement network library in zig 0.16.x pushing std.
• Where the wire meets the will. Every byte owned, every thread deliberate, every route explicit. No hidden cost. Just clean metal and honest code - predictable by principle.
Source Code & Documentation: https://github.com/prothegee/zix
On-Site Campaign Activation System (IoT & Real-Time Data)
• Designed end-to-end architecture for a high-traffic marketing campaign integrating physical IoT vending machines with digital user experiences.
• Authored comprehensive HLD and LLD documents defining strict API contracts, WebSocket geofencing logic, and session security protocols.
• Mitigated third-party integration risks by implementing "defensive interfaces" and mock services for undocumented client/IoT systems ("Grey Areas"), ensuring zero development blockers.
Source Code & Documentation: https://github.com/prothegee/server-backend-audio_transcriber-go
IP-Based Rate Limiter for HTTP/gRPC Servers
• Implemented reusable rate-limiting middleware for both net/http (Go stdlib) and gRPC (google.golang.org/grpc), ensuring consistent traffic governance across service boundaries with minimal external dependencies.
• Designed JSON-based configuration loading for dynamic adjustment of thresholds (max requests/IP, time window, cleanup intervals) without code redeployment, supporting rapid environment adaptation.
• Engineered goroutine-based cleanup routine to prune stale IP entries, preventing memory leaks during long-running operations while maintaining O(1) lookup performance for active rate-limit checks.
Source Code & Documentation: https://github.com/prothegee/network-limiter-go
Domain-Driven Backend Service with Real-Time Kafka/WebSocket Integration
• Applied Domain-Driven Design (DDD) principles to structure business logic, ensuring clear separation between domain models, application services, and infrastructure layers for long-term maintainability.
• Built bidirectional communication flow using Apache Kafka as event backbone and WebSocket endpoints (/ws/stock/trade) for low-latency client updates, enabling live trade data streaming with backpressure handling.
• Implemented comprehensive test suites following TDD methodology, achieving high coverage for critical paths including Kafka producers, WebSocket handlers, and database interactions.
Watch Demo: https://youtu.be/TvGujQngAJ0
Source Code & Documentation: https://github.com/prothegee/server-backend-go
Full-Stack Real-Time Chat Application (Rails + Vue)
• Connected Vue frontend to Rails ActionCable backend using standardized subscription protocol, enabling bidirectional real-time messaging with room-based isolation and immediate message broadcasting to all connected clients.
• Established consistent message schema between backend (Ruby hash) and frontend (TypeScript interface) with runtime validation on both ends, reducing integration bugs and improving developer velocity.
• Designed file-based message persistence (chat_data.json) and minimal Rails setup to eliminate database configuration overhead, allowing focus on core WebSocket logic and UI/UX iteration during early development phases.
Source Code & Documentation: https://github.com/prothegee/chat_app-ruby-vue
High-Performance Full-Stack Content Management Platform
• Leveraged Dragon Framework (C++) to deliver low-latency HTTP services optimized for data-intensive operations, demonstrating suitability for streaming workloads and backend-heavy applications with Kafka integration pathways.
• Developed interactive dashboard using Spel framework with real-time content rendering, enabling instant reflection of backend updates through simple HTTP GET calls without complex client-side state management.
• Implemented CRUD operations for dual entity types (software projects and career postings) with rich metadata support including categorization, external repository links, job levels, status tracking, and timestamped updates.
Watch Demo: https://www.youtube.com/watch?v=kXDB8DX8uYs
Interactive Web Frontend Demo using Godot Game Engine
• Built and hosted an interactive frontend application using Godot engine, accessible via web browser, demonstrating the engine's capability to deliver browser-compatible gaming experiences without native installation.
• Implemented dual input methods supporting keyboard (space bar) and touch/tap interactions, enabling accessibility across desktop and mobile devices from a single codebase.
• Utilized Bun runtime for development server management (bun run demo), facilitating rapid iteration and local testing in a modern JavaScript/TypeScript toolchain environment.
Watch Demo: https://www.youtube.com/watch?v=qbBkc_eAuE8
Secure C++ Backend Library for Cryptography & Data Encoding
• Implemented AES encryption with both CBC (Cipher Block Chaining) and GCM (Galois/Counter Mode) modes, providing authenticated encryption with integrity verification; validated through unit tests confirming round-trip encryption/decryption accuracy and ciphertext non-readability.
• Integrated Argon2 password hashing algorithm—the state-of-the-art for credential protection—with assertion-based unit testing to ensure deterministic verification and resistance against brute-force attacks.
• Built barcode and QR code generation supporting JPEG, PNG, and SVG output formats with 1:1 aspect ratio optimization for scan reliability; applied in IoT product scanning workflows to verify item authenticity and track inventory integrity across supply chains.
Watch Demo: https://www.youtube.com/watch?v=IFKu1ar6cKs
Real-Time Kafka Consumer with Drogon WebSocket Integration
• Implemented librdkafka/cppkafka consumer tightly coupled with Drogon's multi-threaded event loop, enabling non-blocking message ingestion and immediate WebSocket fan-out without thread contention or callback deadlocks in high-throughput scenarios.
• Built /ws/stock/trade WebSocket controller following Drogon's WebSocketController pattern, allowing passive client connections to receive live Kafka-published trade data with zero user interaction required—ideal for monitoring dashboards and real-time analytics frontends.
• Leveraged Drogon's internal thread pool alongside Kafka consumer polling loop, ensuring message processing scales with available cores while maintaining order guarantees per partition through careful synchronization design.
Watch Demo: https://youtu.be/mJvyoLWEgGM
Source Code & Documentation: https://github.com/drogonframework/drogon-examples/tree/main/drogon-kafka
protégé
- One who is under the care and protection of another.
- A person who is guided and supported by an older and more experienced person or mentor.