Résumé / Kasidate Phlaiphueak

From the first question
to working software.

Software Developer

I’m Bank, a software developer in Bangkok. I work across backend services, AI products, identity, and real-time data. I like following a problem from the screen where it appears to the system underneath—and making the whole thing easier to understand.

View PDF résumé Contact me

01 / Experience

From conversations
to connected systems.

2025 — CurrentTelecom Company

End-to-End Solution Architect

Designs implementation-ready solution architecture across AI applications, identity, migration, integration, and privilege models while aligning product, business, data, and engineering constraints.

  • Design end-to-end architecture, system boundaries, and cross-system flows for AI-enabled applications.
  • Plan user migration, identity mapping, transition paths, and service continuity across connected systems.
  • Design privilege and access models that translate business roles into enforceable system permissions.
  • Align business, product, data, security, and engineering requirements into architecture teams can implement and operate.
ArchitectureAI systemsIdentityMigrationIntegrationAccess control

Chatbot Developer Intern

Built conversational product experiences across LINE and Facebook Messenger, connecting reusable UI, messaging APIs, backend services, and business workflows in an Agile delivery environment.

  • Built chatbot experiences for LINE and Facebook Messenger from evolving product requirements.
  • Developed reusable frontend components integrated with the company Chat SDK and messaging APIs.
  • Connected conversational flows, backend services, and business logic into complete user journeys.
  • Worked across product changes, debugging, integration, and iterative delivery in Agile cycles.
LINEMessengerChat SDKMessaging APIsFrontendBackend integration

02 / Selected projects

Systems I designed
and built.

Backend platforms, identity services, real-time data, financial systems and AI-assisted workflows.

01

Fintech · Backend · Real-time

WeThaiInvest

Investment Portfolio & Market Data Platform

Built the financial-state and market-data layers behind an investment platform: a transaction-led portfolio engine for explainable historical calculations, plus a Go market-data gateway for low-latency price, snapshot, OHLC, and aggregate delivery.

My contributionBackend & platform engineering · portfolio architecture · real-time market-data infrastructure

TypeScriptNestJS 11GoChiMongoDB
CONTEXT / LINKS

Public links & context

Architecture & implementation

The challenge

Portfolio results must stay reproducible when users import, edit, void, transfer, or correct historical transactions and when corporate actions change holdings or cash. At the same time, live market reads must remain fast without turning every client request into an upstream provider call.

What I built

  • Designed Portfolio V2 around posted transactions and operation logs as durable history, with deterministic replay for holdings, cash, income, corrections, transfers, and derived portfolio state.
  • Built edit/rebuild and bulk-import workflows that validate historical changes, preview their effects, replay only the affected history, and persist refreshed snapshots instead of hiding expensive work inside one blocking request.
  • Implemented corporate-action dividend and split workflows: provider sync, master-asset mapping, ex-date eligibility, idempotent transaction generation, pending/settled/voided states, automatic jobs, and portfolio rebuild after state changes.
  • Built a transaction-led Benchmark V2 projection with reusable daily snapshots, historical EOD valuation, daily/cumulative TWR, capital and exposure-matched benchmarks, correction neutralization, attribution, and incremental dirty-from-date rebuilds.
  • Developed a Go/Chi market-data gateway exposing JWT-protected price, snapshot, OHLC, and aggregate APIs backed by realtime WebSocket state, Redis caches, and persistent MongoDB stock bars.
  • Added supporting production capabilities across asset search, help-center APIs, async administration flows, provider resilience, metrics, health checks, and monitoring-oriented runtime behavior.

Architecture & decisions

  • Separated the NestJS portfolio/business backend from the Go market-data gateway so financial rules, replay, and user workflows do not compete with high-frequency market ingestion and fan-out.
  • Split the gateway into WSS and HTTP runtime roles: one receiver owns the provider stream and realtime workers while horizontally scalable HTTP nodes serve shared Redis/MongoDB state behind a load balancer.
  • Realtime aggregate events update in-memory price and OHLCV first, then flush changed state to Redis and batch dirty bars to MongoDB; normal reads are cache/database-first rather than provider-per-request.
  • Used layered current-price, last-known, previous-close, snapshot, fresh/stale OHLC, and versioned aggregate caches so the system can degrade gracefully when a provider or one storage layer is unavailable.
  • Persisted portfolio and benchmark read models separately from source transactions; edits mark the earliest affected date dirty so the engine can seed from the preceding snapshot and rebuild only the suffix.
  • Protected corporate-action application with eligibility gates, unique/idempotency keys, explicit settlement state, and deterministic rebuilds so retries and scheduled jobs do not duplicate financial events.

How the system works

  • Portfolio edit/import → validate history → determine earliest affected date → deterministic replay → replace derived snapshots → refresh benchmark/read models.
  • Provider WebSocket aggregate events → in-memory latest price/OHLCV → Redis realtime flush → MongoDB bar flush/finalization → cache-first HTTP price and chart responses.
  • Corporate-action sync → map master asset → evaluate pre-ex-date ownership → create idempotent dividend/split transaction → pending/settled/voided state → rebuild affected portfolio.
  • Benchmark request or worker → compare transaction/operation watermarks → replay dirty range → historical EOD valuation → daily TWR → capital/exposure benchmark → comparison and attribution.

Tools

TypeScriptNestJS 11GoChiMongoDBRedisWebSocketsJWTDockerNginxPrometheusGrafanaSentry
02

AI · Product · Automation

I’m Guide

AI Travel Planning Platform

Built a travel-planning platform that turns preferences and destination context into editable itineraries, while connecting AI generation, conventional planning paths, place data, trip state, social/community interactions, LINE/LIFF surfaces, and operational monitoring.

My contributionBackend / AI workflow engineering · multi-service capstone platform

TypeScriptNestJS 10MongoDBMongooseRedis
CONTEXT / LINKS

Public links & context

Architecture & implementation

The challenge

Trip planning is not a single model prompt: the product has to collect preferences, discover and validate places, construct day-level plans, persist user decisions, support edits and fallback modes, and remain observable when multiple services and external integrations are involved.

What I built

  • Developed a dedicated planner service with custom AI trip generation, AI optimization, preset planning, non-AI generation, and TAT-oriented request paths backed by trip-generation and validation helpers.
  • Modeled activities, favorites, history, preferences, communities, feedback, places, trip/day details, LINE connections, and user-trip state as explicit backend capabilities instead of one monolithic planning response.
  • Built place search/detail/region workflows and connected place data to itinerary generation so generated plans resolve into structured application data that the product can save, validate, and edit.
  • Supported user-facing trip discovery and sharing workflows, including nearby attractions, editable preset-based plans, trip reviews, and community interactions documented in the SIT capstone record.
  • Integrated LINE and LIFF-facing workflows, trip/general notification paths, and supporting internal APIs so itinerary state could move between web/app experiences and messaging interactions.
  • Implemented a separate core service for authentication and shared platform concerns, including JWT/OAuth-related user flows, password recovery, email workflows, WebSocket support, storage/integration services, and API documentation.
  • Added Redis-backed state/caching plus health and operations tooling covering CPU, memory, disk, MongoDB, Redis, external dependencies, logging, metrics, Sentry/New Relic instrumentation, and scheduled work.

Architecture & decisions

  • Separated shared account/core responsibilities from the planner domain, allowing trip generation and place-heavy workflows to evolve without coupling them to every authentication or platform concern.
  • Used MongoDB/Mongoose for flexible trip, place, activity, community, and planner documents, with Redis for fast shared state; the core service also includes relational TypeORM/MySQL capabilities for structured platform data.
  • Converted AI output into structured itinerary/domain state and kept trip-validator/generator helpers around the model path so generated content participates in the same application rules as non-AI plans.
  • Kept AI, optimized-AI, preset, TAT, and non-AI request modes as explicit paths, preserving a conventional fallback instead of making the entire product dependent on one generation route.
  • Built internal-domain guards, request/response logging, global error handling, health indicators, scheduled tasks, and observability integrations as part of the service architecture rather than an afterthought.

How the system works

  • User preferences + trip constraints → choose AI / optimize / preset / non-AI planning path → resolve places → generate day details → validate itinerary → persist trip and user state.
  • LINE/LIFF interaction → identity/user context → core/planner API → trip/activity/community state → notification or updated itinerary returned to the user.
  • Service traffic → request logging + dependency health checks → Redis/Mongo/external indicators → metrics and error monitoring for production diagnosis.

Tools

TypeScriptNestJS 10MongoDBMongooseRedisMySQLTypeORMLINELIFFWebSocketsSentryNew RelicPrometheusWinston
03

Identity · Security · Architecture

MemoID

Identity & Access Platform

Built a central OAuth 2.0 / OpenID Connect identity provider for MemoLab applications and external clients, covering upstream identity brokering, local accounts, SSO, authorization, token lifecycle, consent, logout, account security, and OAuth client administration.

My contributionIdentity platform architecture & implementation

Next.js 16TypeScriptMongoDBJOSEOAuth 2.0
CONTEXT / LINKS

Public links & context

Architecture & implementation

The challenge

An identity provider has to make browser sessions, authorization requests, codes, access/ID/refresh tokens, redirect boundaries, external identity providers, and administrative actions agree under strict security rules—while remaining understandable enough for developers and end users to integrate correctly.

What I built

  • Implemented Google, Microsoft, and LINE upstream OIDC sign-in with state, nonce, and PKCE S256, plus local registration with Brevo email OTP and an opaque HttpOnly central MemoID SSO session.
  • Implemented OAuth 2.0 Authorization Code flow with mandatory PKCE S256, OpenID Connect ID tokens, RS256 access tokens, JWKS publication, exact redirect validation, scopes, consent, and trusted-client behavior.
  • Built rotating opaque refresh-token families with transaction-backed rotation, replay detection, security-event generation, family revocation, configurable idle/absolute lifetimes, and revocation-aware user suspension.
  • Implemented OIDC discovery, OAuth authorization-server metadata, userinfo, token revocation, introspection, RP-initiated logout, exact post-logout URI validation, logout state, user confirmation, and CSRF protection.
  • Built user-facing connected-application/session management and admin-facing OAuth client, credential, user lifecycle, audit, and security-event surfaces, including one-time client-secret display with stored scrypt hashes.
  • Added MongoDB-backed serverless-safe rate limiting, TTL/index bootstrap, security headers, no-store token/session responses, public security/status surfaces, bilingual developer/end-user documentation, and CI validation.

Architecture & decisions

  • Acts as both an external identity broker and the first-party authorization server/OpenID Provider: upstream identities or local credentials resolve to one MemoID user and central SSO session before client authorization begins.
  • Separates authentication and application-entry authorization from each product’s internal business roles; downstream applications reference the stable MemoID subject and own resource-level permission models themselves.
  • Keeps browser SSO sessions opaque/HttpOnly while access and ID tokens are signed and verifiable through JWKS; refresh credentials remain opaque and server-side lifecycle state is persisted for rotation and revocation.
  • Uses exact-match redirect and post-logout allowlists, short-lived single-use authorization codes, PKCE, state/nonce, token-family replay detection, and explicit consent boundaries to reduce token and redirect abuse.
  • Requires MongoDB Atlas/replica-set semantics for refresh rotation transactions and isolates preview/production databases, issuers, signing keys, provider credentials, and OAuth clients.

How the system works

  • Google / Microsoft / LINE / local login → MemoID user resolution → opaque SSO session → authorize request → consent/trust check → single-use code → server/BFF token exchange → ID/access/refresh credentials.
  • Refresh token RT1 → atomic rotation to new access token + RT2 → RT1 becomes unusable; later RT1 reuse → security event → revoke entire refresh family → require reauthentication.
  • Application logout → clear product session → MemoID RP-initiated logout confirmation → validate client + registered post-logout URI → terminate central SSO session → return state to client.

Tools

Next.js 16TypeScriptMongoDBJOSEOAuth 2.0OpenID ConnectPKCE S256JWT / JWKSBrevoVercelGitHub Actions
04

Healthtech · Operations · Backend

Mumya Pharma

Pharmacy Operations Platform

Built a modular pharmacy backend spanning member identity, medicine data, order lifecycle, points/rewards/redemption, user medical information, editorial content, files, notifications, and administrative traceability.

My contributionBackend API & domain engineering

TypeScriptNestJS 11MongoDBMongooseJWT
CONTEXT / LINKS

Public links & context

Private project · No public product demo or source repository.

Architecture & implementation

The challenge

Operational pharmacy software combines customer accounts, sensitive member information, commerce-like orders, a points ledger, rewards, content, and administrator actions. These domains need consistent authorization and error behavior while keeping financial-like point movements and operational changes traceable.

What I built

  • Built local/JWT authentication plus Google and LINE integration, phone verification/OTP paths, role decorators and guards, and user administration including medical-information fields.
  • Implemented medicine-domain APIs and schemas, order create/query/update/cancel workflows, and the supporting validation/service layers used by customer and administrative operations.
  • Designed a points domain with user balances, points ledger, administrative adjustments, reward catalog, redemption records, reward delivery, and dedicated redemption services and API documentation.
  • Built article and news/content management APIs with querying, structured schemas, slugs, and administrative operations so educational/marketing content is managed alongside the operational product.
  • Implemented file handling through an S3-compatible/R2 service with presigned operations and media processing, plus notification/OTP gateways including SMS-oriented verification integration.
  • Added administrative audit records, request IDs, logging interceptors, validation/Mongo/global exception filters, security middleware, and consistent modular NestJS boundaries across the backend.

Architecture & decisions

  • Organized the API as NestJS domain modules—auth, users, medicines, orders, points, content, files, notifications, and audit—so business rules remain near the data and workflow they protect.
  • Uses MongoDB/Mongoose as the primary domain store, with explicit schemas for orders, medicines, users, rewards, redemptions, points ledgers, user points, articles/news, and audit records.
  • Keeps points as ledger-oriented records and separate reward/redemption workflows rather than treating a member balance as an isolated mutable number, improving traceability of earns, adjustments, and redemptions.
  • Applies shared role guards, current-user context, request IDs, logging, validation, and exception normalization across modules to keep customer and admin behavior consistent.
  • Separates binary/media storage from business records through an S3-compatible object-storage service while keeping file processing and access paths inside the application boundary.

How the system works

  • Sign-in / provider login / OTP → authenticated user + role context → guarded domain endpoint → service validation → MongoDB state → audit/logging where applicable.
  • Points operation → validate member/reward and balance rules → ledger / reward / redemption records → update user-points state → return traceable redemption or balance result.
  • Order request → validate user and order payload → create/update/cancel order state → expose query/admin workflow with shared exception and request logging.

Tools

TypeScriptNestJS 11MongoDBMongooseJWTPassportGoogle OAuthLINEAWS SDK / R2SharpSMS / OTPREST APIs
05

Healthtech · AI · Workflow

DentistAI

Dental Practice & Clinical Workflow Platform

Developed a dental-practice backend that connects patient and practitioner records, appointments and blocked schedules, consent, periodontal charting, portals/files/resources, AI-assisted periodontal parsing, and realtime speech transcription.

My contributionBackend systems & AI-assisted clinical workflow engineering

TypeScriptNestJS 11MongoDBMongooseWebSockets
CONTEXT / LINKS

Public links & context

Private project · No public product demo or source repository.

Architecture & implementation

The challenge

Clinical workflow data is both structured and time-sensitive: bookings must respect availability, periodontal measurements need a stable chart model, speech/AI output has to be converted into validated clinical structure, and sensitive actions require explicit identity, role, consent, and audit boundaries.

What I built

  • Built patient and doctor modules plus appointment booking, availability checks, slot queries, rescheduling, cancellation, service catalog, calendar, and blocked-time scheduling workflows.
  • Implemented consent records and APIs, patient/doctor-facing portal resources, file metadata/workflows, health endpoints, user management, and local/Google/JWT authentication with roles and password/OTP support.
  • Designed periodontal history and chart schemas plus DTOs capable of representing detailed chart measurements as structured clinical data rather than free-form text.
  • Built a periodontal processing pipeline with parser, AI service, normalization, flatten/patch/serialize utilities, quadrant handling, quality checks, and QA helpers around the structured chart model.
  • Integrated realtime speech transcription through a WebSocket gateway and Soniox session layer so live clinical speech can be streamed into backend transcription workflows.
  • Added audit interception and explicit role guards around clinical/administrative surfaces, keeping AI/transcription features as supporting inputs to persisted workflow rather than bypassing domain validation.

Architecture & decisions

  • Uses modular NestJS services with MongoDB/Mongoose schemas for patients, doctors, appointments, consent, periodontal records, schedules, users, files/resources, and supporting workflow state.
  • Keeps the periodontal domain as its own pipeline: raw/assisted input is parsed, normalized, quality-checked, patched into the chart model, and serialized separately from general patient CRUD.
  • Uses WebSocket infrastructure for realtime transcription sessions while conventional HTTP modules own durable clinical and operational state.
  • Combines local/Google authentication, JWT, role guards, OTP/password recovery, consent records, and an audit interceptor to establish boundaries around sensitive health workflows.
  • Includes OpenAI-facing AI integration in the clinical backend, but structured schemas, parser/QA utilities, and explicit service boundaries remain the system of record around generated assistance.

How the system works

  • Appointment request → resolve doctor/service/schedule → availability or slot check → book / reschedule / cancel → persist appointment and schedule state.
  • Clinical speech → WebSocket transcription gateway → Soniox realtime session → transcription service → clinical workflow consumes the captured text.
  • Periodontal input or assisted text → parser / AI service → normalize + quality/QA → patch structured periodontal chart → persist patient periodontal history.
  • Sensitive action → authenticated user → role/consent boundary → domain service → MongoDB record + audit behavior.

Tools

TypeScriptNestJS 11MongoDBMongooseWebSocketsSonioxOpenAIJWTGoogle OAuthRBACEmail OTPClinical data modeling

03 / Technology stack

The tools
behind the work.

Languages & foundations

JavaScriptTypeScriptJavaGoPythonSQLHTML5CSS3

Frontend & mobile

ReactNext.jsVue.jsTailwind CSSReact NativeExpoThree.jsFramer Motion

Backend & APIs

Node.jsNestJSSpring BootSpring MVCJava ServletsJSP / JSTLJPA / HibernateGo FiberGo ChiREST APIsMVC architectureMaven

Databases & caching

MongoDBMongooseMySQLPostgreSQLMicrosoft SQL ServerOracle DatabaseRedisTypeORM

Cloud & platforms

CloudflareCloudflare R2FirebaseNetlifyVercelOracle APEX

Infrastructure & DevOps

Linux / UbuntuVPS / VMDockerDocker ComposeNginxSSHBash / ShellGitGitHubGitLab CI/CDGitHub Actions

Monitoring & observability

PrometheusGrafanaGrafana AlloyLokicAdvisorNode ExporterNginx ExporterSentryNew Relic

AI & automation

OpenAI APILangChainNode-RED

Identity, integration & realtime

04 / Working style

How I show up.

Curious before confident

I prefer to understand why something behaves the way it does before deciding how it should be changed.

Build to understand

A small working prototype often makes trade-offs clearer than a long discussion about the perfect abstraction.

Notice the edges

Loading, failure, recovery, wording, and the awkward path between screens are part of the product, not cleanup work.

Calm beats clever

I like technical depth, but I want the experience around it to stay clear, quiet, and easy to trust.

Founder of MemoLab

I founded MemoLab as a place to turn useful ideas into products, tools, publishing, and experiments with a real public life.

05 / Education

Bachelor of Science in Information Technology

King Mongkut's University of Technology Thonburi

2021 — 2025
GPAX 3.80 · First Class Honors

Continue the conversation

Have something
in mind?

Tell me about the role, the team, or the problem you want to solve.

Get in touch
Kasidate Phlaiphueak · Software engineering & architecturekasidate.me
Stories, products & useful placesEsc to close