About
The TY Multiverse Journey
THE STORY
From an idea to shared research
TY Multiverse began with an idea: bring market data, research reports and company perspectives together so the reasoning behind research is easier to follow.
Starting with personal research and tools, the platform is gradually connecting macroeconomics, industries and companies. The aim is a place where people can explore, share and test ideas together. The journey continues, and we welcome others to help shape it.
{
printf 'REPO: '
git remote get-url origin
git --no-pager log -n 50 --stat --date=iso-strict --pretty=format:'===COMMIT===%nHASH: %H%nDATE: %cI%nMSG: %s%n%b%n---FILES---'
} > git-last-50-commits.txt
less git-last-50-commits.txtTEAM
Building the future together
Tianyi Kao
TY Multiverse · Maya Sawa
Background
KAO TIAN YI
tianyikao@tymultiverse.cc
Java Backend Engineer specializing in enterprise systems, security integration, and high-concurrency backend architecture. Experienced in Spring Boot, Spring Security, Redis, PostgreSQL, RabbitMQ, Kubernetes, OAuth2/Keycloak, and enterprise API gateway integration. Previously worked in banking, macro research, and fintech strategy before transitioning into enterprise software engineering.
Expertise
Core backend expertise in Spring Boot layered architecture, PostgreSQL/Redis performance tuning, and RabbitMQ async processing. Proficient in enterprise security with Keycloak/JWT/OAuth2, and DevOps workflows spanning Jenkins, Docker, and Kubernetes on OCI/OpenShift. Hands-on experience building AI retrieval systems with LangChain RAG and pgvector hybrid search. Additional frontend exposure in Angular and Flutter.
Career Briefing
First Principles
- I treat systems like a chessboard.
- Instead of rushing to code, I first map out the structure of the problem.
- Where others see bugs, latency, or compatibility errors, I see the edges of a puzzle waiting to be solved.
- My instinct is not to patch, but to design a path that ensures long-term stability.
- When I ask questions like 'What is the essence of this process?' or 'Why does this feel counterintuitive?', I'm not looking for shortcuts—I’m uncovering the principles beneath the surface.
- This way of thinking shaped how I worked with Kubernetes.
- At first, I took the quick route—exposing all nodes to the public internet. It worked, but it was fragile. Later, I reframed the question: instead of asking 'How do I keep containers alive?', I asked 'What boundaries should protect the cluster itself?'. That shift led me to redesign the setup with private nodes and Batison operators, giving the workloads stronger isolation and governance.
- The same mindset guided me when new nodes came with restrictive CPU limits. Rather than just tweaking quotas, I restructured the flow by introducing RabbitMQ. This offloaded spikes, smoothed throughput, and turned what seemed like a scaling problem into an opportunity to upgrade the architecture.
Foundations That Led Here
- EY Auditor: VBA macros revealed passion for redesigning processes.
- Far Eastern Bank Fintech PM (2021-2022): RPA automation showed me code's power to save hundreds of hours.
- From that moment, I knew engineering was my path.
- Tarobo Investment Macro Associate (2022-2023): Daily Python coding for trading strategies became more engaging than research.
- In small coding experiments, I felt passion turning logic into running systems.
- This contrast pushed me to career transition.
- Not because finance was bad, but because I wanted 'creation' rather than 'documentation'.
- Every successful debug proved my choice was right.
- EY: I automated reconciliations with VBA, not to save hours for its own sake, but because I was drawn to the elegance of redesigning processes. Far Eastern Bank: building RPA bots for 31 workflows and prototyping BNPL taught me how code could turn repetitive operations into scalable systems. I even designed a B2B2C model where Bankee served as the entry point and a cryptocurrency exchange provided KYC onboarding—a thought experiment in mapping transaction events into auditable logs. Tarobo: integrating Shioaji tick data and automating backtests wasn't about chasing alpha alone, but about seeing how logic could self-execute as living systems. These projects deepened the contrast: finance prized documentation, while I craved creation. That's why I pursued JavaScript and JavaEE training, built Django apps, set up Jenkins pipelines, and containerized workloads with Docker. Toastmasters shaped another layer: the ability to transform abstract principles into vivid, shareable narratives. Together, these experiences formed the foundation: every script, prototype, and debug reinforced my shift from documenting reality to building it.
Battlefield
- Core: Spring Boot microservices, REST controllers, security filters.
- Django ASGI/ORM/REST.
- Celery async LLM retrieval.
- Docker/K8s for microservices.
- Redis distributed locks
- RabbitMQ for async processing
- PostgreSQL composite + GIN indexes, 5× retrieval boost.
- Algorithms: weekly LeetCode drills – Binary Trees, DP, Backtracking, Sliding Window.
- API Gateway: rewrote JOIN queries, added composite indexes, built caching layers. Retrieval systems: pg_trgm + pgvector hybrid, GIN + IVFFlat indexes, fallback logic to reduce hallucinations, provider rate-limiting. Infrastructure: containerized with Docker, K8s autoscaling, Terraform networking on OCI with VCN/Bastion/OKE. CI/CD: Jenkins pipelines. Reliability: Redis session management, WebSocket STOMP push, chain-of-responsibility for exceptions, JUnit5/Mockito coverage. Data: HikariCP tuning, ORM N+1 fix, batched queries reducing GC churn. Spring Boot: mastered layered architecture, Spring Security JWT filters, async @Scheduled tasks, optimized RestTemplate/WebClient. Algorithms: solved 200+ LeetCode problems focusing on production applications – Binary Trees for caching/indexing, DP for job scheduling, Backtracking for search optimizations.
Next Iteration
- Focus: high-concurrency architecture, asynchronous pipelines, distributed data systems, guided by DDIA.
- Product: build data-intensive flows that integrate AI modules, turn prototypes into user-facing MVPs.
- AI: generative models, prompt engineering, retrieval-augmented pipelines, embedding stores.
- Inspiration: Modular-style toolchains, assembling best-of-breed systems.
- Forward roadmap: concurrency – refine Java CompletableFuture pools, explore Project Loom virtual threads, optimize non-blocking I/O with WebFlux and Netty
- queues – benchmark RabbitMQ for throughput vs durability, backpressure handling, dead-letter strategies
- database – incremental materialized views, sharding experiments, adaptive query caching
- pipelines – batch embedding updates, retrieval accuracy tuning with hybrid pgvector + ANN, consistency checks across shards
- AI – LLM-based doc routing, cost-aware tokenization, multi-provider orchestration, evaluation harness for accuracy/latency/cost tradeoffs
- product – systematize side projects into MVPs, create feedback instrumentation, run A/B feature toggles, refine onboarding flows
- team – knowledge base from Toastmasters, peer review rituals, ownership rotation. Guiding star: DDIA principles applied to AI systems – immutability, streaming-first, fault-tolerance, scalability, traceability – each new iteration strengthens data flow resilience while keeping product usable.
Project Experience
Software Engineer
Software Engineer
- 2026/08 ~ 2026/10 - Payment Review & Confirmation Reprinting: Implemented domestic-payment maker-checker integration, preserved payment payloads during form changes, and connected authorization queues, work items, and checker transaction details. Built transaction-confirmation reprint search/reset and grid actions, customer-number validation, bilingual messages, print-template resolution, statement retrieval, and BPM request/response transformations. Extended PDF reprinting with parallel record retrieval, template-based grouping, and restored multi-row templates for dual-currency and structured-product confirmations. Pre-opened the first PDF tab during the user click and provided links for blocked additional popups, with loading-state cleanup and error feedback.
- 2026/10 - Accounting Reference Data: Integrated an Angular accounting-code creation form with the backend create operation, initialized form values during component startup, and configured organization, financial classification, and product-type dropdown mappings.
- 2026/07 ~ 2026/09 - Regulatory Reporting & Cash Transactions: Integrated central-bank report media-data services and request mappings. Implemented large-amount transaction reporting through frontend interceptors and services, used backend responses to determine reporting requirements, handled missing report records and background checks, and extended coverage to cash withdrawals. Updated cash-deposit/reversal components and introduced shared imports and lazy-loaded payment routes.
- 2026/04 ~ Present - Enterprise Account Security & Validation: Diagnosed authentication/session, cookie persistence, CSRF/CORS, and request lifecycle issues across enterprise banking systems. Implemented AccountUsage/TWCT validation workflows, multilingual code-table integration, reconciliation logic, and Angular reactive-form validation flows. Modernized customer-maintenance create, view, and modify journeys with grid-row context transfer, read-only controls, date normalization, automatic branch identification, and consistent post-submit dialogs. Strengthened UI resilience through HTTP 500 messaging, delete-operation safeguards, and defensive state recovery across browser interceptors, backend filters, controller binding, and centralized exception handling flows. Further refined individual/corporate customer payloads, FATCA fields, address updates, hidden-field handling, and required-field validation.
- 2026/03 ~ Present - Enterprise Gateway Architecture Optimization: Refactored enterprise gateway architecture using centralized route registry, Adapter, and Facade patterns to reduce hardcoded route coupling and improve maintainability. Built custom request transformers and pagination aggregators for legacy backend integrations and downstream response normalization. Standardized branch identity propagation through API endpoint alignment, request-header fallback rules, and reusable middleware inserters. Delivered maker-checker and send-back integrations while rehosting SIO, SIP, CIF, CAI, CRM, MARS, and payment services through Jolt transformations, XML service definitions, and environment-specific configuration.
- 2026/01 ~ Present - Thumbnail Asset Manager — High-Performance Media App: (I) Controller Pooling: Engineered VideoPlayerController pool to resolve hardware decoder contention and optimize memory usage. (II) Visual Effects: Developed seamless Boomerang (Forward+Reverse) loops via precise seek control. (III) Unified Caching: Built AssetCacheManager for persistent storage of both image and video assets. (IV) Asset Probing: Implemented VideoProber for background discovery and metadata extraction.
- Flutter architecture design
- performance tuning
- cache strategy
- and visual effect implementation
- ThumbManager
- Structure: Controller Pool / Asset Cache / Prober; Logic: Memory Management & Background Discovery
- 2025/12 ~ 2026/03 - Printing Confirmation: Delivered Angular frontend and Java middleware-gateway enhancements across enterprise printing-confirmation workflows. Built reusable frontend strategies, validation handling flows, and XML/JSON gateway routing integrations. Refactored frontend architecture to reduce duplicated business logic and improve maintainability. Developed Flutter-based media application with controller pooling, memory optimization, and unified asset caching workflows.
Open Source Backend Engineer
Open Source Backend Engineer
- 2025/04 ~ 2025/12 - Document Management System: Built Spring Boot backend with Redis Session, Spring Security, WebSocket, retry handling, and PostgreSQL optimization. Implemented REST APIs, ACL/versioning workflows, and real-time notification systems. Added JUnit5/Mockito testing and Grafana/Prometheus monitoring.
- 2025/01 ~ 2025/03 - External Portal & Website: Implemented Redis TTL caching, distributed locking, session fixation protection, and concurrency-control workflows. Tuned high-load endpoints through cache optimization and request-flow analysis. Built ordered global exception handling for enterprise backend APIs.
- 2024/08 ~ 2024/09 - DevOps Management Portal: Configured Spring Security, JWT, OAuth2 Resource Server, Keycloak/RedHat SSO, and RBAC authorization workflows. Designed secure authentication/session-management strategies for enterprise systems.
- 2024/06 ~ 2024/07 - Cloud Infrastructure & Kubernetes Deployment: Designed OCI infrastructure including VCN, OKE, subnets, bastion, and load balancers using Terraform. Automated infrastructure provisioning and Kubernetes deployment workflows.
- 2024/03 ~ 2024/05 - System Modernization & Deployment: Built JBoss WAR CI/CD pipelines supporting 10+ servers and containerized legacy applications. Upgraded Java applications from Java 8/11 to Java 17 and migrated 20+ RHEL servers.
Freelance Software Engineer
Freelance Software Engineer
- 2024/10 ~ 2024/12 - Customer Portal Q&A Assistant (FastAPI + LangChain): Built FastAPI + LangChain RAG chatbot with PostgreSQL pg_trgm/pgvector hybrid retrieval pipelines using GIN and IVFFlat indexes. Designed multi-LLM fallback workflows, no-knowledge handling strategies, and conversational context retrieval pipelines. Implemented hybrid semantic/full-text retrieval workflows and prompt orchestration for enterprise-style knowledge systems. Developed chat-history persistence and retrieval logic for conversational AI applications.
- 2023/07 ~ 2023/09 - SmartSync Crawler (WordPress Plugin): Developed automated WordPress crawler plugin with secure admin controls and XPath-based product extraction workflows. Implemented timeout-resilient crawling, content normalization, UTF-8 CSV export, and structured content-generation pipelines. Built URL collection, data extraction, and content-processing workflows for automated product synchronization.
- 2023/03 ~ 2023/06 - Restaurant Booking & CMS Platform (Vue 3 + Spring Boot): Built Vue 3 + Spring Boot booking and CMS platform with JWT/RBAC authentication and business-management workflows. Developed reservation, menu, customer, branch, coupon, and order-management modules with RESTful API architecture. Delivered BI dashboards, analytics workflows, and Docker-based deployment environments.
Macro Associate
Macro Associate
- 2022/12 ~ 2023/01 - Maintained and enhanced data infrastructure across 10+ databases for comprehensive market analysis, optimizing data flow architecture for multi-source financial data integration
- 2022/11 ~ 2022/12 - Analyzed macroeconomic indicators including container shipping trends, US retail sales, TWD currency flows, foreign exchange dynamics, and EPFR fund flows for cross-asset allocation strategies, mapping market behavior patterns to investment decision frameworks
- 2022/10 ~ 2022/11 - Delivered daily market intelligence reports covering emerging markets (Mexico, India, Brazil) with real-time analysis, utilized scikit-learn, statsmodels and scipy for data analysis and statistical modeling, structuring complex market data into actionable insights through systematic data flow analysis
- 2022/09 ~ 2022/10 - Built automated reporting workflows; integrated SinoPac Shioaji trading API for market data ingestion and strategy prototyping, designing real-time market analysis data processing pipelines; utilized pandas, numpy and scipy for futures price and implied volatility data analysis, implementing automated backtesting frameworks and quantitative trading strategies (Red K strategy, volatility-based dynamic rebalancing strategy)
Fintech PM, MA Program
Fintech PM, MA Program
- 2022/04 ~ 2022/05 - Created cross-industry alliance strategies with 3 proposals approved through internal review processes, resulting in 2 successful implementations, analyzing integration requirements and data exchange protocols
- 2022/02 ~ 2022/03 - Managed 31 operational procedures for the digital payment department ensuring compliance and efficiency, designing workflow logic and data validation processes; implemented open-source RPA solutions using Python with Selenium for process automation and workflow optimization
- 2021/12 ~ 2022/01 - Conducted comprehensive research on emerging fintech trends including BNPL, cryptocurrency, and online microloan product design with weekly reporting, mapping product features to user behavior patterns
- 2021/10 ~ 2021/11 - Developed 20+ business plan drafts and successfully proposed 2 digital payment projects in collaboration with major telecommunications companies, analyzing user journey flows and payment processing logic
- 2021/08 ~ 2021/09 - Built Power BI dashboards for executive and product (Bankee) KPIs; designed data models and visuals to support business reviews, translating complex business requirements into structured data flows
Auditor
Auditor
- 2020/02 ~ 2020/03 - Audited and analyzed 20+ Balance Sheets/Income Statements and 3+ Cash Flow Statements, structuring financial reporting data flows for compliance and analysis purposes
- 2020/01 ~ 2020/02 - Developed sensitivity analyses for interest rate and foreign currency exposures, along with Top 10 Suppliers/Customers concentration analysis, creating data-driven risk assessment models
- 2019/12 ~ 2020/01 - Performed 40+ substantive analytical procedures to validate account variations and identify potential discrepancies, developing systematic approaches to financial data analysis and anomaly detection
- 2019/11 ~ 2019/12 - Coordinated audit procedures across 8 specialized teams for financial services clients including equity funds and bond funds, mapping complex financial product structures to audit testing frameworks
- 2019/10 ~ 2019/11 - Conducted comprehensive financial statement audits covering Current Assets, Fixed Assets, Liabilities, and Equity for 20+ client engagements, analyzing financial data flows and transaction processing logic
- 2019/09 ~ 2019/10 - Automated reconciliation workflow using Excel VBA to accelerate audit working papers, designing logical data validation processes for financial data integrity
Education
RedHat
2024/12- Red Hat JBoss Application Administration I (AD248)
iSpan
2023/10~2024/2- JavaEE Career Development Program
FreeCodeCamp.com
2023/7~2023/9- JavaScript Algorithms and Data Structures
- Data Visualization
Hong Kong Polytechnic University
2020/9~2021/9- Master of Finance in Investment Management
Fu Jen Catholic University
2013/9-2018/6- B.B.A. in Finance and International Business
Temple University
2016/8-2017/5- Global Exchange Program
Tech Experience
Software Engineer
Frontend Development
flowchart LR
subgraph "Presentation Layer (Widget-based SPA)"
W["Reusable Form Widgets<br/>(TextBox / CheckBox / TypeAhead)"]
GRID["Data Grid<br/>List + Row Actions"]
FORM["Entity Maintenance Screens<br/>(Create / View / Modify)"]
W --> FORM
GRID --> FORM
end
subgraph "Dual-Control Workflow"
MK["Maker<br/>Submit Change"]
CK["Checker<br/>Review & Approve"]
SB["Send Back<br/>for Correction"]
MK --> CK
CK -->|"reject"| SB
SB --> MK
end
subgraph "BFF Layer"
BFF["Backend for Frontend<br/>Versioned Release Train"]
HDR["Header Enrichment<br/>Organisational Unit / Channel"]
CFG["Externalised Config<br/>Per-environment Matrix"]
BFF --> HDR
BFF --> CFG
end
subgraph "Domain Microservices"
MS1["Customer Domain"]
MS2["Payment Domain"]
MS3["Reference Data"]
end
subgraph "Legacy Core (Rehosting)"
BR["Protocol Bridge<br/>RPC to REST Adapter"]
TP["Transaction Processing Monitor<br/>(Legacy Core Banking)"]
BR --> TP
end
FORM -->|"REST API"| BFF
CK -->|"REST API"| BFF
HDR --> MS1
HDR --> MS2
HDR --> MS3
MS1 --> BR
MS2 --> BR
classDef ui fill:#1d4ed8,stroke:#1e3a8a,color:#ffffff
classDef mc fill:#6b21a8,stroke:#581c87,color:#ffffff
classDef bff fill:#9a3412,stroke:#7c2d12,color:#ffffff
classDef ms fill:#0f766e,stroke:#115e59,color:#ffffff
classDef lg fill:#166534,stroke:#14532d,color:#ffffff
class W,GRID,FORM ui
class MK,CK,SB mc
class BFF,HDR,CFG bff
class MS1,MS2,MS3 ms
class BR,TP lgflowchart TD
UI["Widget UI<br/>form state · validation · accessibility"] --> BFF["BFF API<br/>versioned endpoint"]
BFF --> AUTH["Security boundary<br/>token · role · channel checks"]
AUTH --> MAP["Request mapper<br/>UI DTO ↔ canonical model"]
MAP --> HDR["Header inserter<br/>organisation · channel · correlation ID"]
HDR --> ROUTE{"Target domain"}
ROUTE --> CUST["Customer service adapter"]
ROUTE --> PAY["Payment service adapter"]
ROUTE --> REF["Reference-data adapter"]
CUST --> LEGACY["Protocol bridge<br/>REST ↔ legacy RPC"]
PAY --> LEGACY
REF --> CACHE["Reference cache"]
LEGACY --> CORE["Transaction Processing Monitor<br/>legacy core banking"]
CORE --> RESP["Error mapping · audit · response DTO"]
CACHE --> RESP
RESP --> UI
classDef ui fill:#1d4ed8,stroke:#1e3a8a,color:#ffffff
classDef bff fill:#9a3412,stroke:#7c2d12,color:#ffffff
classDef service fill:#0f766e,stroke:#115e59,color:#ffffff
classDef legacy fill:#6b21a8,stroke:#581c87,color:#ffffff
classDef data fill:#166534,stroke:#14532d,color:#ffffff
class UI ui
class BFF,AUTH,MAP,HDR,RESP bff
class ROUTE,CUST,PAY,REF service
class LEGACY,CORE legacy
class CACHE dataBackend Development
Java
- Developed backend business logic and middleware control using Java. Created and modified Java files to set up Inserter Beans for dynamic injection of specified headers before forwarding requests to downstream systems.
- Configured routing and services (XML config), modifying files like service_extn_gsp.xml to declare and bind API call methods (e.g. GET to POST) and map request parameters correctly.
- Deepened Spring Security troubleshooting across the authentication filter chain, including FilterChainProxy ordering, custom filter placement with addFilterBefore/addFilterAfter, OncePerRequestFilter behavior, SecurityContextPersistenceFilter, SessionRepositoryFilter, and SecurityContextHolder THREADLOCAL strategy.
- Analyzed session-based authentication behavior by tracing HttpSession/SecurityContext binding, Authentication object structure, AnonymousAuthenticationToken fallback, session creation policy (IF_REQUIRED/STATELESS), JSESSIONID cookie delivery, SameSite/Secure flags, CSRF generate/validate flow, and CORS preflight requests blocked by security filters.
- Diagnosed authentication failure modes by separating unauthenticated requests, expired sessions, filter-level rejections, missing cross-domain cookies, and 401/403 authorization outcomes.
- Refactored middleware header inserter components across multiple banking modules to implement a three-tier fallback strategy for injecting entity, user-id, and branch-no headers: prefer caller-supplied header overrides, fall back to the auth system, then fall back to hardcoded environment defaults.
- Created a dedicated header inserter bean for external third-party system integration, injecting authorization tokens from Spring @Value-bound properties and setting standardized headers including pagination controls.
- Implemented a custom request transformer replacing declarative JSON field mapping with Java-driven transformation logic; handles multi-envelope request structure detection and performs field key aliasing for downstream service compatibility.
- Designed a pagination aggregator to transparently auto-paginate a backend code list API and collapse all pages into a single merged response; resolved Spring bean resolution issue by explicitly registering aggregator components in XML-based aggregator configuration.
- Integrated banking services through Jolt request/response transformations, XML service definitions, pagination configuration, and SQL URI/process mappings; extended BPM orchestration for confirmation printing with template resolution and statement retrieval.
General
- Implemented Gateway interface integration, applying Adapter and Facade patterns to encapsulate complex legacy system interfaces and smooth frontend/backend spec differences. Maintained Externalized Config parameter tables, ensuring config/code separation and environment migration flexibility.
- Implemented and debugged financial account flows for BGL/Internal Account modules, separating Account DTO/Entity/VO responsibilities and applying AccountUsage-driven field status, conditional UI behavior, backend validation, mutually exclusive fields, and dependent-field validation.
- Handled TWCT-related account validation, including ID Type/ID Number alphanumeric constraints, customer group mapping, mirror-account data consistency, ReconRequired downstream behavior, and ReconDirection debit/credit flow checks.
- Maintained system code and multilingual dropdown mapping with code_id/code_name/seq structure, code range governance, language-row mapping, frontend dropdown to backend enum translation, display-name/value separation, cache strategy, and concurrency risk awareness around max(code_id)+1 manual numbering.
- Traced API behavior from browser request through frontend interceptor, backend filter, and controller, checking Cookie/Authorization/Content-Type headers, session domain/path/SameSite issues, GET/POST CSRF differences, JSON DTO binding failures, @ControllerAdvice handling, and unified error response contracts.
- Connected domestic-payment maker-checker flows with authorization queues, work items, and checker transaction-detail navigation; preserved payment payloads during form changes.
- Integrated central-bank report media-data services and mappings, and implemented large-amount reporting checks using backend responses, including missing-record handling and cash-withdrawal support.
Open Source Backend Engineer
Backend Development
Java
- Implemented factory design pattern for decoupling - https://github.com/Vinskao/TY-Multiverse-Backend
- Implemented real-time WebSocket backend handling multi-threaded message queues using Java ExecutorService, ConcurrentHashMap, and async tasks. Delivered system metrics and order info to frontend via channel push, ensuring non-blocking processing across data sources.
- Developed CRUD APIs using Spring Boot framework and integrated with SSO server.
- Used JPA, MyBatis, and JDBCTemplate to implement data access layer across Spring Boot and legacy JBoss applications. Designed entity mappings and SQL queries for CRUD and batch operations.
- Designed and implemented RESTful APIs for order processing and account management using Spring MVC. Implemented unit and integration tests with JUnit 5 and Mockito. Applied Servlet 5 Filters for CORS and validation, using Maven for build management.
classDiagram
class ApplicationPlatform {
+Async execution
+Scheduled work
+Caching
+Realtime transport
}
class SecurityBoundary {
+Authentication
+Authorization
+Cross-origin policy
+Session policy
}
class IntegrationBoundary {
+Identity-provider integration
+Token lifecycle
+External-service adapters
}
class CacheAndSessionStore {
+Cache lifecycle
+Session persistence
+Distributed coordination
}
class DataAccessLayer {
+Connection pooling
+Transaction boundary
+Query execution
+Health monitoring
}
class PersistentStore {
+Durable records
+Indexes
+Batch operations
}
ApplicationPlatform --> SecurityBoundary
ApplicationPlatform --> CacheAndSessionStore
ApplicationPlatform --> DataAccessLayer
SecurityBoundary --> IntegrationBoundary
SecurityBoundary --> CacheAndSessionStore
CacheAndSessionStore --> PersistentStore
DataAccessLayer --> PersistentStoreflowchart TD
CLIENT["Browser / API Client"] --> TOMCAT["Embedded Tomcat<br/>Servlet Container"]
subgraph SERVLET["Servlet request pipeline"]
TOMCAT --> FILTER["Servlet Filter Chain<br/>CORS / request logging / Spring Security"]
FILTER --> DS["DispatcherServlet<br/>Spring MVC front controller"]
DS --> HM["HandlerMapping<br/>find Controller method"]
HM --> PRE["HandlerInterceptor.preHandle<br/>trace / tenant / audit checks"]
PRE --> BIND["HandlerMethodArgumentResolver<br/>JSON body + @Valid binding"]
BIND --> CTRL["@RestController<br/>request orchestration"]
CTRL --> SVC["@Service<br/>transactional business logic"]
SVC --> REPO["@Repository<br/>JPA / JDBC data access"]
REPO --> DB[("PostgreSQL")]
end
DB --> REPO
REPO --> SVC
SVC --> CTRL
CTRL --> POST["HandlerInterceptor.postHandle<br/>response metadata"]
POST --> CONV["HttpMessageConverter<br/>object to JSON"]
CONV --> FILTEROUT["Filter Chain returns response"]
FILTEROUT --> CLIENT
CTRL -. "throws exception" .-> ADVICE["@RestControllerAdvice<br/>central error response"]
SVC -. "throws exception" .-> ADVICE
ADVICE --> CONV
classDef entry fill:#1d4ed8,stroke:#1e3a8a,color:#ffffff
classDef spring fill:#166534,stroke:#14532d,color:#ffffff
classDef data fill:#92400e,stroke:#78350f,color:#ffffff
classDef error fill:#9f1239,stroke:#881337,color:#ffffff
class CLIENT,TOMCAT entry
class FILTER,DS,HM,PRE,BIND,CTRL,SVC,REPO,POST,CONV,FILTEROUT spring
class DB data
class ADVICE errorclassDiagram
class SecurityBoundary {
+Cross-origin policy
+Token-based authentication
+Resource-server validation
+Method-level authorization
}
class TokenValidation {
+Bearer token extraction
+Signature and issuer validation
+Claim-to-authority mapping
+Expiry enforcement
}
class AuthorizationPolicy {
+Public-route policy
+Authenticated-route policy
+Role and permission evaluation
+Least-privilege access
}
class SessionPolicy {
+Session lifecycle
+Fixation protection
+Concurrent-session control
+Server-side session store
}
class IdentityIntegration {
+Authorization-code redirect
+Token exchange
+Identity lookup
+Token introspection
}
SecurityBoundary --> TokenValidation
SecurityBoundary --> AuthorizationPolicy
SecurityBoundary --> SessionPolicy
SecurityBoundary --> IdentityIntegrationflowchart TD
REQ["Client request<br/>Bearer token"] --> CORS["Cross-origin policy"]
CORS --> SC["Security context"]
SC --> JWT["Token extraction"]
JWT --> DEC["Token validation<br/>signature · issuer · expiry"]
DEC --> AUTH["Claims-to-authorities mapping"]
AUTH --> AUTHZ["Route authorization"]
AUTHZ --> APP["Application boundary"]
APP --> POLICY["Method authorization"]
POLICY --> RESP["Sanitized response"]
DEC -. "invalid token" .-> ENTRY["Unauthenticated response"]
AUTHZ -. "insufficient permission" .-> DENIED["Unauthorized response"]
POLICY -. "access denied" .-> DENIED
classDef security fill:#92400e,stroke:#78350f,color:#ffffff
classDef mvc fill:#166534,stroke:#14532d,color:#ffffff
classDef error fill:#9f1239,stroke:#881337,color:#ffffff
class CORS,SC,JWT,DEC,AUTH,AUTHZ security
class APP,POLICY,RESP mvc
class ENTRY,DENIED errorclassDiagram
class GlobalExceptionHandler {
+Chain of Responsibility
+Error Response Builder
}
class BusinessApiExceptionHandler {
+@Order(0)
+BusinessException
}
class DataIntegrityApiExceptionHandler {
+@Order(1)
+DataIntegrityViolationException
}
class ValidationApiExceptionHandler {
+@Order(2)
+MethodArgumentNotValidException
}
class DefaultApiExceptionHandler {
+@Order(Integer.MAX_VALUE)
+Generic Exception
}
GlobalExceptionHandler --> BusinessApiExceptionHandler
GlobalExceptionHandler --> DataIntegrityApiExceptionHandler
GlobalExceptionHandler --> ValidationApiExceptionHandler
GlobalExceptionHandler --> DefaultApiExceptionHandlerflowchart TD
REQ["HTTP Request"] --> MVC["DispatcherServlet"]
MVC --> INVOKE["Invoke Controller method"]
INVOKE --> VALID["@Valid / data binding"]
INVOKE --> SERVICE["@Service / @Transactional"]
SERVICE --> DATA["@Repository / database"]
VALID -. "MethodArgumentNotValidException" .-> RESOLVER
SERVICE -. "BusinessException" .-> RESOLVER
DATA -. "DataIntegrityViolationException" .-> RESOLVER
INVOKE -. "unexpected Exception" .-> RESOLVER["HandlerExceptionResolver chain"]
RESOLVER --> ADVICE["@RestControllerAdvice"]
ADVICE --> BIZ["@ExceptionHandler BusinessException<br/>@Order 0"]
ADVICE --> INTEGRITY["@ExceptionHandler DataIntegrityViolationException<br/>@Order 1"]
ADVICE --> BINDING["@ExceptionHandler MethodArgumentNotValidException<br/>@Order 2"]
ADVICE --> FALLBACK["@ExceptionHandler Exception<br/>lowest precedence"]
BIZ --> ERR["Problem detail / error DTO<br/>HTTP status + code + trace id"]
INTEGRITY --> ERR
BINDING --> ERR
FALLBACK --> ERR
ERR --> RESP["JSON Error Response"]
classDef spring fill:#166534,stroke:#14532d,color:#ffffff
classDef error fill:#9f1239,stroke:#881337,color:#ffffff
class MVC,INVOKE,VALID,SERVICE,DATA spring
class RESOLVER,ADVICE,BIZ,INTEGRITY,BINDING,FALLBACK,ERR,RESP errorPython
Node.js
- Used Mongoose.js for schema definition and queries in MongoDB-powered dashboards.
PHP
General
Frontend Development
Vue
React
Angular
General
- Built Astro website with React useState integration
- Developed Thymeleaf MVC and Handlebars CRUD APIs
- Developed Vue.js 2 3 with Vuex integration
- Maintained Angular as the primary gateway frontend framework, modifying extensive .component.ts and .html files (e.g., refactoring showMessage UI behavior to alertDialog / errLabel, and refreshing component state data), and managing Angular Routing (app-routing.module.ts)
- Developed visual styles using SCSS / CSS, updating site-wide shared component libraries (widget.scss) and Angular module-specific stylesheets (e.g., MaintainPrintingOfTransactionNotification.scss)
- Implemented localization and i18n by modifying dictionary files such as package.js and package_zh.js, enabling multi-language translation mapping for the frontend application
- Centralized API routes into a global configuration using Registry and Singleton patterns, establishing a Single Source of Truth to eliminate hardcoded paths and enhance modular cohesion.
Mobile & App Development
Mobile Frameworks
Performance & Architecture
- Developed high-performance media playback application using Flutter and Dart.
- Implemented complex Boomerang effects and memory pooling for video controllers.
- Engineered unified caching systems for cross-platform media management.
- Automated asset discovery with persistent probing and background task management.
Database
Relational
- Integrated PostgreSQL with Keycloak SSO, LangChain, and multiple backend REST API frameworks
- Maintained DB Access Layer for MSSQL in JBoss EAP
- Upgraded JBoss from EAP 7 to EAP 8 and containerized JBoss 7 for 20+ servers
- Used PostgreSQL transaction blocks (with Spring @Transactional) to ensure atomic updates for order matching, record insertion, and position updates. Designed composite indexes (e.g., status + timestamp) for efficient query of latest records, and avoided unnecessary indexes to balance write performance.
- Implemented N-Gram indexing for full-text search using PostgreSQL pg_trgm extension, supporting fuzzy matching and similarity search across multiple languages. Built hybrid search systems combining N-Gram and vector search for semantic and character-level text retrieval.
NoSQL
- Deployed Redis server with producer (API server with visit count API) and consumer (deployed individually) services to record website visit counts for handling large numbers of concurrent requests
- Integrated Redis for form state management system, implementing session storage and temporary data caching, with Lua scripts for atomic operations and application-level integration for data persistence and state synchronization.
- Implemented RabbitMQ-based asynchronous message processing architecture with producer-consumer pattern. Designed TYMBackendApplication as producer with AsyncMessageService and RabbitMQConfig for message publishing. Deployed RabbitMQ 4.1 Management server as message broker with queue management and async processing capabilities. Built dedicated Consumer Pod for message processing and database write operations, ensuring reliable message delivery and fault tolerance. This architecture enables scalable, decoupled communication between backend services and database operations, supporting high-throughput message processing with guaranteed delivery semantics.
Existing classic queues continue to process asynchronous work, while write-side business events are published through a transactional outbox to the replayable tymb-events stream. Events remain in PostgreSQL during a RabbitMQ outage and are delivered automatically after recovery.
graph LR
A["Backend<br/>Spring Boot<br/>AsyncMessageService"] --> B["RabbitMQ<br/>Queues & Exchanges"]
subgraph K8s["Kubernetes Runtime"]
K1["Kubelet<br/>Probe Manager"]
K2["startupProbe<br/>/actuator/health"]
K3["readinessProbe<br/>/actuator/health/readiness"]
K4["livenessProbe<br/>/actuator/health/liveness"]
C["Consumer Pod<br/>Spring Boot WebFlux<br/>Reactive RabbitMQ + R2DBC"]
end
subgraph Biz["Business Queue Consumers"]
Q1[weapon-save]
Q2[weapon-delete-all]
Q3[people-insert-multiple]
Q4[people-delete-all]
Q5[async-result]
end
C --> D["PostgreSQL<br/>R2DBC"]
K1 --> K2 --> C
K1 --> K3 --> C
K1 --> K4 --> C
B --> C
C --> Q1
C --> Q2
C --> Q3
C --> Q4
C --> Q5
classDef producer fill:#1d4ed8,stroke:#1e3a8a,color:#ffffff
classDef mq fill:#6b21a8,stroke:#581c87,color:#ffffff
classDef consumer fill:#166534,stroke:#14532d,color:#ffffff
classDef database fill:#9f1239,stroke:#881337,color:#ffffff
classDef k8s fill:#1e3a8a,stroke:#172554,color:#ffffff
classDef queue fill:#92400e,stroke:#78350f,color:#ffffff
class A producer
class B mq
class C consumer
class D database
class K1,K2,K3,K4 k8s
class Q1,Q2,Q3,Q4,Q5 queueflowchart LR
API["Backend API<br/>Spring Boot"] -->|"AMQP commands"| CQ["Classic work queues<br/>existing async jobs"]
subgraph OKE["OKE Kubernetes Runtime"]
RMQ["RabbitMQ 4.1 StatefulSet<br/>AMQP 5672 · Stream 5552"]
PVC[("OCI Block Volume PVC<br/>50 GiB · persistent")]
SECRET["Kubernetes Secret<br/>RabbitMQ credentials"]
CONSUMER["Consumer Pod<br/>Spring WebFlux + R2DBC"]
PUBLISHER["Outbox Publisher<br/>confirm + retry/backoff"]
RMQ --- PVC
SECRET -.-> RMQ
SECRET -.-> CONSUMER
end
CQ --> RMQ --> CONSUMER
CONSUMER -->|"business write + event<br/>one transaction"| PG[("PostgreSQL<br/>business_event_outbox")]
PG --> PUBLISHER
PUBLISHER -->|"event.* · publisher confirm"| EX["tymb-event-exchange<br/>durable topic exchange"]
EX -->|"event.#"| STREAM[("tymb-events stream<br/>append-only · replayable<br/>30 days / 10 GiB retention")]
classDef producer fill:#1d4ed8,stroke:#1e3a8a,color:#ffffff
classDef mq fill:#6b21a8,stroke:#581c87,color:#ffffff
classDef consumer fill:#166534,stroke:#14532d,color:#ffffff
classDef database fill:#9f1239,stroke:#881337,color:#ffffff
classDef infra fill:#1e3a8a,stroke:#172554,color:#ffffff
class API producer
class CQ,RMQ,EX,STREAM mq
class CONSUMER,PUBLISHER consumer
class PG database
class PVC,SECRET infraflowchart TD
Q["Classic work queue"] --> C["WebFlux consumer"]
C --> TX["Reactive transaction"]
TX --> WRITE["Write business data"]
TX --> EVENT["Insert BusinessEvent into outbox"]
WRITE --> COMMIT["Commit both writes"]
EVENT --> COMMIT
COMMIT --> ACK["ACK work command"]
EVENT --> POLL["Poll unpublished rows"]
POLL --> SEND["Publish event.* with eventId"]
SEND --> STREAM["Append to tymb-events stream"]
STREAM --> CONFIRM{"Publisher confirm ACK?"}
CONFIRM -->|"yes"| DONE["Set published_at"]
CONFIRM -->|"no / unavailable"| BACKOFF["Keep unpublished<br/>exponential backoff"]
BACKOFF --> POLL
DEDUPE["Downstream consumers<br/>deduplicate by eventId"]
STREAM --> DEDUPE
classDef mq fill:#6b21a8,stroke:#581c87,color:#ffffff
classDef reactive fill:#166534,stroke:#14532d,color:#ffffff
classDef data fill:#9f1239,stroke:#881337,color:#ffffff
classDef retry fill:#92400e,stroke:#78350f,color:#ffffff
class Q,SEND,STREAM mq
class C,TX,POLL,CONFIRM,ACK reactive
class WRITE,EVENT,COMMIT,DONE,DEDUPE data
class BACKOFF retryInfrastructure & Deployment
Containerization & Orchestration
- Implemented PV and PVC for database data persistence
IaC & Automation
- Used Terraform to provision infrastructure on OCI and configure networking, compute, and storage resources. Automated deployment with Ansible for multi-node environments. Created and templated Helm charts for application rollout and upgrade across namespaces.
Servers & Middleware
- Set up volumes for containerized JBoss EAP 7 for real-time configuration updates
- Configured systemctl for JBoss EAP 8 and JBoss containers for auto-start on restart
System Architecture
- Implemented thread pool patterns for concurrent task processing and resource management in high-performance applications.
Monitoring & Visualization
- Integrated Prometheus with Spring Boot Actuator for collecting JVM and custom metrics. Visualized real-time data using Grafana dashboards. Monitored JBoss runtime via Jolokia and collected traces with Instana.
CI/CD
- Built Jenkins Server and implemented CI/CD pipelines using Jenkins and Jenkins Credentials for Spring Boot, Django, Laravel, and Astro projects
graph LR
A[GitHub Repository] --> B[Clone and Setup]
B --> C[Build with Node.js]
C --> D[Build Docker Image with BuildKit]
D --> E[Push to Docker Hub]
E --> F[Deploy to Kubernetes]Network
Protocols
- Built chat room and Spring Boot Actuator metrics exporter with WebSocket, using STOMP for message broker
Load Balancing & Ingress
- Deployed Nginx Ingress Controller with all services exposed through ingress and cert-manager TLS, and Nginx Static File Server for serving static files.
- Applied round-robin load balancing for stateless services and integrated Nginx for static assets delivery. Used cert-manager with ACME to issue and auto-renew TLS certificates for ingress.
Cloud
Platforms
- Deployed bare-metal K8S server on OCI with public subnet and ingress configuration.
- Provisioned OKE with bastion in public subnet, operator VM in private subnets, and OKE control plane on private endpoint; configured public/internal load balancers and route tables (IGW/NAT/Service Gateway), with kubectl access via SSH proxy through bastion.
flowchart LR
user["User"] -->|SSH 22| bastion["Bastion (Public Subnet)"]
subgraph OCI VCN
direction LR
subgraph Public["Public Subnets"]
bastion
pubLB["Public LB Subnet (OCI LB - Reserved IP)"]
end
subgraph Private["Private Subnets"]
operator["Operator VM"]
cp["OKE Control Plane (Private Endpoint)"]
workers["Worker Nodes (NodePool size=2, A1.Flex 1c/8GB/50GB)"]
intLB["Internal LB Subnet"]
end
subgraph Gateways["Network Gateways"]
ig["Internet Gateway"]:::net
nat["NAT Gateway"]:::net
sg["Service Gateway"]:::net
end
pubRT["Public Route Table"]:::net --> ig
privRT["Private Route Table"]:::net --> nat
privRT --> sg
bastion -.-> pubRT
pubLB -.-> pubRT
operator -.-> privRT
workers -.-> privRT
intLB -.-> privRT
end
bastion -->|SSH Proxy| operator
operator -->|kubectl 6443| cp
pubLB --> workers
intLB --> workers
%% Improve contrast with vivid class definitions
classDef host fill:#1d4ed8,stroke:#1e3a8a,color:#ffffff;
classDef control fill:#5b21b6,stroke:#4c1d95,color:#ffffff;
classDef compute fill:#166534,stroke:#14532d,color:#ffffff;
classDef net fill:#92400e,stroke:#78350f,color:#ffffff;
%% Assign classes for better differentiation
class bastion host;
class pubLB,intLB,cp control;
class operator,workers compute;
class pubRT,privRT net;Tools
Systems
- Upgraded RHEL from 7 to 8 for 20+ servers
Scripting
- Used Bash and Shell scripts to automate backup, deployment, and log rotation for RHEL-based systems. Used Python scripts to call APIs, process logs, and integrate with third-party services for data extraction and cleanup.
Others
- Used Yum Repository and Satellite to get files for upgrading RHEL
- Developed WordPress plugin to crawl double-layered data in Elementor ecommerce form
Security & Authentication
Identity Provider / SSO
- Built Keycloak SSO server and implemented authorization code OIDC method to connect public and confidential clients - https://github.com/Vinskao/keycloak-client-demo
Protocols & Flows
Framework & Keys
- Built Keycloak SSO server and implemented authorization code OIDC method to connect public and confidential clients - https://github.com/Vinskao/keycloak-client-demo
- Updated Keycloak 18 to 26 on K8S, persisted data to PostgreSQL
- Updated Keycloak SPI to Quarkus 3 from Quarkus 2, and implemented Keycloak username-password authentication flow using Informix stored procedure
- Implemented CDI to inject entity manager to DAO layer
sequenceDiagram
participant User as User
participant App as Application
participant Auth as Authorization Server
participant API as Resource Server
User->>App: 1. Access Application
App->>Auth: 2. Redirect to Authorization Page
User->>Auth: 3. Login and Authorize
Auth->>App: 4. Return Authorization Code
App->>Auth: 5. Exchange Code for Token
Auth->>App: 6. Return Access Token
App->>API: 7. Access Resources with Token
API->>App: 8. Return Protected ResourcesAI
Frameworks & APIs
- For Maya Sawa V1, Built knowledge-based RAG chatbot using FastAPI framework with LangChain and OpenAI APIs with multi-character personality system. Implemented name detection for character profiles, semantic search for people, and vector similarity search for document context. Used LLMChain and PromptTemplate to build query workflows with personality prompt builders. Parsed and embedded documents, exposed query interface via FastAPI, and orchestrated flow with tools and chains. Integrated Redis for chat history management and session storage. Built multi-layered architecture with API Layer (FastAPI Router), Q&A Layer (QAChain, PageAnalyzer), Support Layer (NameDetector, ProfileManager, PeopleWeaponManager, PersonalityPromptBuilder, VectorStore, ChatHistoryManager), and External Services integration (OpenAI API, People System API, PostgreSQL, Redis).
- For Maya Sawa V2, Built advanced QA system using Django framework with hybrid search capabilities combining trigram and vector search in PostgreSQL using pg_trgm and pgvector extensions. Implemented full-text retrieval pipeline with GIN indexes for trigram search and IVFFlat indexes for vector search. Added support for multiple AI providers (OpenAI, Gemini, Qwen, Mock) through AIResponseService. Built comprehensive service layer with FilterChainManager, KMSourceManager, ChatHistoryService, and AIResponseService. Enhanced data layer with PostgreSQL, Redis, and Celery Broker integration. Maintained backward compatibility while adding advanced features like model management, health checks, and legacy chat history support.
- Implemented N-Gram indexing techniques in AI applications for fuzzy text matching and semantic search. Used PostgreSQL pg_trgm extension for trigram-based similarity search, enabling typo-tolerant queries and multi-language text retrieval in RAG systems.
Maya Sawa V2
graph TD
%% User and Entry
U["User"] --> Q["ask-with-model API<br/>question"]
Q --> P["Full-text Retrieval Pipeline"]
%% Retrieval Process
subgraph "Pipeline"
P --> N["Normalize/Lowercase<br/>trim punctuation"]
N --> E{"Compute Embedding?"}
E -- Yes --> EM["OpenAI Embeddings<br/>(text-embedding-3-small) → qvec"]
E -- No --> SKIP["Skip vector branch"]
%% PostgreSQL Retrieval (Trigram & Vector)
subgraph "PostgreSQL"
direction LR
PG1["Trigram Search<br/>content % :query<br/>similarity(content, :query) as text_sim"]:::trgm
PG2["Vector Search<br/>1 - (embedding <=> :qvec) as vec_sim"]:::vec
IDX1["GIN Index<br/>idx_articles_content_trgm<br/>(content gin_trgm_ops)"]:::idx
IDX2["IVFFlat Index<br/>idx_articles_embedding_ivfcos<br/>(embedding vector_cosine_ops)"]:::idx
EXT1["EXTENSION pg_trgm<br/>set_limit(:min_sim)"]:::ext
EXT2["EXTENSION pgvector"]:::ext
end
EM --> PG2
SKIP -.-> PG1
N --> PG1
PG1 --> MRG["Merge & Rank<br/>score = 0.6*text_sim + 0.4*vec_sim"]
PG2 --> MRG
MRG --> TOPK["Top-K Articles"]
end
%% Post-processing and Response
TOPK --> CTX["Build Context from Articles<br/>(title + snippet)"]
CTX --> AI["LLM Call (OpenAI/Gemini/Qwen/Mock)"]
AI --> RESP["Answer + Citations/No Knowledge Notice"]
RESP --> RDS["Redis ChatHistory<br/>chat:session:{sid}"]
RESP --> OUT["API Response"]
%% Database Table and Indexes
subgraph "articles schema"
TBL["articles<br/>- id BIGSERIAL PK<br/>- file_path VARCHAR(500) UNIQUE<br/>- content TEXT NOT NULL<br/>- file_date TIMESTAMP NOT NULL<br/>- embedding vector"]:::tbl
end
TBL -. indexed by .-> IDX1
TBL -. indexed by .-> IDX2
%% Styles
classDef trgm fill:#1d4ed8,stroke:#1e3a8a,stroke-width:1px,color:#ffffff
classDef vec fill:#9f1239,stroke:#881337,stroke-width:1px,color:#ffffff
classDef idx fill:#92400e,stroke:#78350f,stroke-width:1px,color:#ffffff
classDef ext fill:#5b21b6,stroke:#4c1d95,stroke-width:1px,color:#ffffff
classDef tbl fill:#166534,stroke:#14532d,stroke-width:1px,color:#ffffffgraph TB
subgraph "Frontend Layer"
A[User Interface] --> B[API Client]
end
subgraph "API Layer"
B --> A1[ask-with-model<br/>Async Processing]
B --> A2[task-status<br/>Task Status Query]
B --> A3[available-models<br/>Available Models List]
B --> A4[add-model<br/>Add Model]
B --> A5[chat-history<br/>Chat History]
B --> A6[legacy-chat-history<br/>Legacy Chat History]
B --> A7[healthz<br/>Health Check]
end
subgraph "Processing Layer"
P1[Async Processing<br/>Celery Task]
P2[Task Status Management<br/>Redis/Celery]
end
subgraph "Agent Service Layer"
AS[MayaAgentService<br/>Unified Service Entry]
end
subgraph "Workflow Layer"
WF[MayaAgentWorkflow<br/>Graphical Workflow]
N1[Intent Classification Node<br/>FilterChain]
N2[Knowledge Retrieval Node<br/>KMSourceManager]
N3[Tool Selection Node<br/>Smart Tool Selection]
N4[Tool Execution Node<br/>PDF/OCR/Calculation/Search]
N5[AI Response Generation Node<br/>LLM Call]
N6[Result Saving Node<br/>Data Persistence]
N7[Error Handling Node<br/>Exception Handling]
end
subgraph "Capability Support Layer"
LLM[LLM Capability<br/>OpenAI/Gemini/Qwen]
TOOLS[Tool Capability<br/>PDF/OCR/Calculation/Search]
MEMORY[Memory Capability<br/>Redis/Vector Memory]
RAG[RAG Capability<br/>pgvector/Hybrid Retrieval]
end
subgraph "Data Layer"
D1[(PostgreSQL<br/>Conversations/Articles)]
D2[(Redis<br/>Cache/Memory/Celery)]
D3[(RabbitMQ<br/>Celery Broker)]
end
subgraph "External Systems"
E1[Paprika API<br/>Knowledge Base Content]
E2[OpenAI API<br/>GPT-4o/GPT-4.1]
E3[Google Gemini API<br/>Gemini Pro/Flash]
E4[Qwen API<br/>Qwen Turbo/Plus]
end
%% API to Processing Layer
A1 --> P1
A2 --> P2
%% Processing Layer to Agent Service Layer
P1 --> AS
%% Agent Service Layer to Workflow Layer
AS --> WF
%% Workflow Node Connections
WF --> N1
WF --> N2
WF --> N3
WF --> N4
WF --> N5
WF --> N6
WF --> N7
%% Workflow Nodes to Capability Layer
N1 --> LLM
N2 --> RAG
N3 --> TOOLS
N4 --> TOOLS
N5 --> LLM
N6 --> MEMORY
%% Capability Layer to Data Layer
LLM --> D1
TOOLS --> D1
MEMORY --> D2
RAG --> D1
%% Celery Tasks to Data Layer
P1 --> D3
P2 --> D2
%% External System Connections
LLM --> E2
LLM --> E3
LLM --> E4
RAG --> E1
%% Style Definitions
classDef api fill:#166534,stroke:#14532d,stroke-width:3px,color:#ffffff
classDef process fill:#92400e,stroke:#78350f,stroke-width:3px,color:#ffffff
classDef agent fill:#1d4ed8,stroke:#1e3a8a,stroke-width:3px,color:#ffffff
classDef workflow fill:#9a3412,stroke:#7c2d12,stroke-width:3px,color:#ffffff
classDef capability fill:#9f1239,stroke:#881337,stroke-width:3px,color:#ffffff
classDef data fill:#166534,stroke:#14532d,stroke-width:3px,color:#ffffff
classDef external fill:#6b21a8,stroke:#581c87,stroke-width:3px,color:#ffffff
class A1,A2,A3,A4,A5,A6,A7 api
class P1,P2 process
class AS agent
class WF,N1,N2,N3,N4,N5,N6,N7 workflow
class LLM,TOOLS,MEMORY,RAG capability
class D1,D2,D3 data
class E1,E2,E3,E4 externalsequenceDiagram
participant U as User
participant F as Frontend
participant A as API
participant C as Celery Worker
participant DB as Database
U->>F: Send Question
F->>A: POST /maya-v2/ask-with-model/
A->>DB: Create Task Record
A->>C: Send Processing Task
A-->>F: Return task_id
F-->>U: Show Processing
loop Poll Status
F->>A: GET /maya-v2/task-status/{task_id}
A->>C: Query Task Status
C-->>A: Return Status
alt Task Complete
A-->>F: Return AI Response
F-->>U: Display Result
else Processing
F-->>U: Show Processing
end
endTools
- Set up local GPU inference with NVIDIA Container Toolkit and WSL2 on Windows. Used Colab for LLM prototyping and rapid experimentation. Tuned prompt behavior and latency benchmarks between local and remote environments.
Claude Cloud Agents
- For the TY Multiverse market dashboard, scheduled two Claude Code cloud routines (cron, Claude Sonnet 5.5 on the subscription) that refresh the buy/neutral/sell AI analyses after the Taiwan close and after the US close and macro releases, each run rediscovering holdings, comparing data cutoffs and skipping instruments without new data.
- Gave the agents a scoped write key stored as a cloud-environment network secret, so the proxy injects the header outside the sandbox and the agent never sees it; the server keeps only the key's SHA-256, limits it to the analysis endpoint and rejects stale writes by revision. Chose subscription-run routines over Claude API billing after comparing cost and setup.
Freelance Software Engineer
Personality & Career Overview
Results-driven and pragmatic, KTY approaches every problem through the lens of feasibility, efficiency, and deliverability — prioritizing actionable output over theoretical exploration.
Rationally analytical at the core, he relies on logic and structured thinking to navigate complex or high-pressure situations. His decision-making consistently returns to the fundamentals: what is the nature of this problem, and what do the rules and logic dictate? This stable, affect-neutral approach consistently improves problem-solving quality.
Strong systems thinker who naturally decomposes complexity into manageable modules, analyzing systems through architecture, data flow, and component relationships. He habitually evaluates trade-offs via A/B comparison and proactively identifies bottlenecks — in performance, concurrency, or resource usage — to drive continuous optimization.
In short: a logic- and data-driven engineering mindset that pairs execution speed with optimization discipline, capable of rapidly pinpointing root causes and shipping grounded solutions even under shifting requirements.