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.

A message from the founder

TEAM

Building the future together

FOUNDER

Tianyi Kao

TY Multiverse · Maya Sawa

Software Development Experience3.7 yrsProject Management Experience0.8 yrsFinance Experience0.9 yrs (11 months)Total Professional Experience5.3 yrs

Background

KAO TIAN YI

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

Tata Consultancy Services2025/12~Present
  • 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

Mercuries Life Insurance2024/3~2025/12
  • 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

Self-Employed (Client Sources Confidential)2023/3~2024/12
  • 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

Tarobo Investment Advisors2022/9~2023/1
  • 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

Far Eastern Int'l Bank2021/8~2022/5
  • 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

EY2019/9~2020/3
  • 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

Tata Consultancy Services2025/12~Present
Frontend Development
Angular.jsTypeScriptSCSS / CSSi18n / LocalizationRegistry PatternSingleton PatternSingle Source of Truth
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 &amp; 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 lg
flowchart 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 data
Backend Development
Java
Java 8 11 17 21
  • 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
RESTful APIAPI GatewayXML ConfigurationChain of ResponsibilityAdapter PatternFacade PatternExternalized Configuration
  • 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

Mercuries Life Insurance2024/3~2025/12
Backend Development
Java
Java 8 11 17 21Spring Framework 6Spring Boot 2 3Spring WebFluxNettySpring Session RedisQuarkus 3Reactive StreamsExecutorServiceConcurrentHashMapVirtual ThreadsForkJoinPoolVirtualThreadTaskExecutorContinuationFiberJPAMybatis 3JDBCTemplateHikariCPJUnit 5MokitoServlet 5MavenRestTemplate@RabbitListenerFilterChainProxyOncePerRequestFilterSecurityContextPersistenceFilterSessionRepositoryFilterSecurityContextHolderAuthentication PrincipalAnonymousAuthenticationTokenSession Creation PolicyCSRF FlowCORS Preflight DebuggingPagination AggregatorCustom Request Transformer
  • 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 --> PersistentStore
flowchart 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 error
classDiagram
    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 --> IdentityIntegration
flowchart 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 error
classDiagram
                                          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 --> DefaultApiExceptionHandler
flowchart 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 error
Python
Python 3Django RestDjango ASGIWSGI Worker PatternPoetry
Node.js
Node.jsExpress.jsAsync/AwaitEvent LoopMongoose.js
  • Used Mongoose.js for schema definition and queries in MongoDB-powered dashboards.
PHP
General
RESTful APISwaggerMicroservicesAPI GatewaySpring Cloud GatewayWeb CrawlerXML ConfigurationChain of ResponsibilityAdapter PatternFacade PatternExternalized ConfigurationRequest Lifecycle DebuggingGlobal Exception HandlerDTO ValidationAccount Domain ModelingConditional ValidationFinancial Reconciliation FlowSystem Code TableCode Table CacheMulti-language Code Mapping
Frontend Development
Vue
Vue.js 2 3
React
React.jsReact HooksReact Context
Angular
Angular.jsReactive FormsFormGroupFormControlFormArrayvalueChangesstatusChangesDynamic ValidatorsAsync ValidatorOnPush Change Detection
General
JavaScriptTypeScriptjQueryAJAXAxiosBootstrapSweetAlert2HTML2CanvasJSPDFJestAstro.jsFile-based RoutingAstro IslandsClient-side HydrationAstro View TransitionsMDXHandlebarsThymeleafCKEditor 5WebpackBundleD3SCSS / CSSi18n / LocalizationRegistry PatternSingleton PatternSingle Source of Truth
  • 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
Flutter 3.xDart 3.xMVVM ArchitectureDio / NetworkingProvider / State
Performance & Architecture
AssetCacheManagerController PoolVideoProbershared_preferencesflutter_cache_manager
  • 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
PostgreSQLR2DBCPGVectorpg_trgmN-Gram IndexTrigram SearchFuzzy SearchFull Text SearchGIN IndexHybrid SearchMSSQLSQLiteMySQLInformix
  • 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
MongoDBFirebaseRedisRabbitMQMessage QueueAsynchronous ProcessingProducer-Consumer PatternCelery
  • 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.
Verified: persistent RabbitMQ event architecture

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 queue
flowchart 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 infra
flowchart 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 retry
Infrastructure & Deployment
Containerization & Orchestration
DockerPodmanKubernetesBare Metal K8SOCP K8S
  • Implemented PV and PVC for database data persistence
IaC & Automation
TerraformAnsibleHelmYAML
  • 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
JBoss EAP 7 8TomcatRabbitMQ
  • 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
Thread Pool
  • Implemented thread pool patterns for concurrent task processing and resource management in high-performance applications.
Monitoring & Visualization
GrafanaPrometheusJolokiaInstanaResilience4jCircuit BreakerMicrometerSpring Boot Actuator
  • 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
JenkinsDocker BuildKitGitHub Package
  • 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
HTTPHTTP/1.1HTTP/2WebSocketSTOMPSSL/TLS
  • Built chat room and Spring Boot Actuator metrics exporter with WebSocket, using STOMP for message broker
Load Balancing & Ingress
IngressNginx Ingress ControllerNginx Static File ServerPublic Load BalancerNAT GatewayEgresscert-manager
  • 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
OCIOKEBastionGCP
  • 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
LinuxRHEL 7 8 Runtime ImageUbuntu
  • Upgraded RHEL from 7 to 8 for 20+ servers
Scripting
ShellBash
  • 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
CursorAntigravityYum RepositorySatelliteGoogle Apps ScriptGitHub SubmoduleClaude CodeClaude Agent SDKMCP
  • 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
Keycloak 18 26Keycloak SPIRedHat SSO 7
Protocols & Flows
OAuth2Authorization Code FlowJWT
Framework & Keys
Spring SecurityDigital SignatureJava KeystoreSpring Security Filter ChainSession SecurityCSRF ProtectionCORS Security
  • 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 Resources
AI
Frameworks & APIs
LangGraphpgvectorIVFFlat IndexVector SearchN-Gram in RAGTrigram SimilarityFuzzy Text Matching
  • 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:#ffffff
graph 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 external
sequenceDiagram
    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
    end
Tools
WSL2NVIDIA Container ToolkitColabCodexGemini Code AssistOllamaOpen WebUIContinueOpenAI-compatible APIbaseURL OverrideModel RoutingStreaming ResponseRepo Context IndexingPrompt Completion Flow
  • 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
Claude Code RoutinesCron-Scheduled Cloud AgentsCloud EnvironmentsNetwork Secrets (Credential Proxy)Network Access AllowlistScoped Agent Write KeySubscription vs API Billing
  • 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

Self-Employed (Client Sources Confidential)2023/3~2024/12
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.

Architecture Diagrams

TY的智慧庫

你有事?
問前想清楚,機會不是誰都有。

💡 建議主題:

放大圖片