THEO KIMBackend & Cloud Systems Engineer

Backend engineering. Cloud experience.

I’m Theo, a backend and cloud engineer. I’m interested in what happens when a system outgrows its original design, and how to help it evolve.

AVAILABLE FOR WORK13 projects28 technical posts

Professional experience

Backend Researcher · SmartDoctor

Backend and cloud engineering across 10 clinical products and 1,000+ independently hosted hospital databases, from booking and clinical rules to service isolation and deployment.

Problems I’ve worked through

A closer look at performance, reliability and infrastructure. Open a case for the decisions and results.

  1. Making slow APIs fasterCache expensive reads while keeping changes from other systems in sync.
    Historical result
    2s → 0.2sReservation response time
    Problem & constraints

    Clinics running the C# EMR and database on underpowered PCs complained about sluggish reservation boards and relied on manual refresh. Repeated reads across a reservation flow involving roughly 50 tables created CPU and memory pressure; most API delay was in database queries and fetching.

    Legacy programs also wrote to hospital databases, so API-only cache invalidation could miss changes. I tried CDC, but maintaining connectors across 1,000 database hosts was unmanageable and the Kafka–Debezium connections were unstable.

    What I changed
    I replaced the hospital-host CDC approach with database triggers that advance a cache version when relevant columns change. The API batch-fetches only required DTO fields, assembles results by key, and applies staff-specific filters after the cache lookup. Separately, I compared packet timings and network paths to isolate extra query-fetch delay in an NCP VPC, then led evidence-based technical meetings with NCP engineers.
    Result & scope
    Fetching only changed fields cut this API's client data transfer and Spring Boot memory use by 90% each; response time fell from 2 seconds to 0.2 seconds. I drove the separate network investigation through NCP's cause confirmation and completed fix.
    Read the engineering write-up
  2. Preserving behavior through a migrationCompare executed SQL and calculated results to trace differences beyond API responses.
    Historical result
    450Initial validation cases passed after corrections
    Problem & constraints

    A prescription could save successfully yet produce different patient charges if rounding, tax or night/holiday surcharge rules changed. The C#-to-Kotlin migration needed evidence that calculations and processing still matched the legacy system.

    Calculation rules were spread across C# branches and SQL. Matching API responses could conceal different amounts or writes, so verification had to check operation order and changes to prescriptions with existing receipts.

    What I changed
    I built a comparison back office, captured executed SQL and bound values from both implementations, and compared their operation order. I traced differences through calculation branches and queries, corrected the implementation, and repeated verification across successive test waves.
    Result & scope
    The initial 450-case wave passed after corrections. Payment-related cases followed separately; the comparison made differences inspectable rather than relying on response equality.
    Read the engineering write-up
  3. Keeping work moving through outagesAccept requests now and deliver them when downstream systems recover.
    Implemented workflow
    CDC → SQSBookings while hospital databases are offline
    Problem & constraints

    Online bookings continued after hospital PCs and their databases shut down. Accepting a booking and applying it to the hospital database could not depend on the same live request.

    Delivery intent had to remain after the request ended, including when external dispatch failed after the database write. Offline hospitals needed a different retry policy from other processing failures. This CDC source was the central reservation-platform outbox, not connectors on 1,000 hospital hosts.

    What I changed
    I persisted delivery work in the central outbox and used Debezium CDC to publish committed inserts to Kafka. A consumer dispatched hospital-grouped SQS messages or the specified API work, then recorded the handled state and acknowledged the Kafka event. This separated capturing committed work from hospital-specific delivery.
    Result & scope
    Kept hospital delivery work in SQS until successful handling. Offline databases followed a delayed retry path; repeatedly failing messages moved to a DLQ with diagnostic notification. Booking acceptance remained separate from destination availability and failure handling.
    Read the engineering write-up
  4. Tracing hidden database bottlenecksFollow a slow query from application code to the database driver.
    Historical result
    −80%Execution time for queries that missed their indexes
    Problem & constraints

    During the Kotlin/Spring Boot migration, slow SQL Server lookups were not using the intended VARCHAR index. Query-plan comparisons traced the access-path change to string parameters sent as Unicode.

    Existing hospital programs depended on different physical column definitions. I could not change every schema, and changing parameter binding alone would not fix the separate getNString getter-conversion rejection.

    What I changed
    I set sendStringParametersAsUnicode=false for ordinary strings while retaining selected @Nationalized mappings. I traced Hibernate into JDBC internals and implemented a Spring @PostConstruct hook using reflection/Unsafe to add NCHARACTER to the CHARACTER/LONG_CHARACTER getter rules and conversionMap.
    Result & scope
    Corrected ordinary-string binding without changing hospital tables and made the pinned driver's getter accept VARCHAR → NCHAR reads. Database CPU usage fell 20%, and execution time fell 80% for queries that had missed their intended indexes. The getter workaround depended on that version's private driver internals.
    Read the engineering write-up
  5. Distributing resource-heavy workloadsSeparate workloads and rebalance them as resource demand changes.
    Historical result
    2,000 → 400Hikari connection pools per pod, on average
    Problem & constraints

    After the ECS-to-EKS migration, per-hospital Hikari connection pools still accumulated roughly 900 database-related threads in one pod. Its 1 GB heap used about 900 MB even after GC.

    I needed to change how each pod retained pools for multiple hospitals. Usage also differed by hospital, so fixed group membership could leave a few pods carrying most of the load.

    What I changed
    I proposed and implemented hospital groups so each pod connected to its assigned hospitals. I aligned Istio routing and Helm/ArgoCD releases with those groups, alongside group-specific scaling and shared tracing.
    Result & scope
    When heavy hospitals concentrated load on particular pods, I reviewed resource metrics with operations to distinguish temporary spikes from sustained load, then mostly regrouped hospitals manually. This distributed hospital pools and load across pods. Reduced the average number of Hikari connection pools per pod from 2,000 to 400.
    Read the engineering write-up
  6. Turning monitoring into improvementsUse production monitoring to guide query and index improvements.
    Historical result
    >30% ↓Average database load after query and index tuning
    Problem & constraints

    Distinguishing EKS resource problems from database queries or application execution meant following information across Prometheus, Grafana, OpenTelemetry and Jaeger. Investigations needed a connected path from infrastructure anomalies to code execution.

    Broader APM, DBM, log and Java-profile coverage had to fit within the existing monitoring budget. I needed to calculate both new charges and costs removed from the existing setup to evaluate adoption and plan the migration.

    What I changed
    I led vendor discussions, cost analysis and the migration. With APM, DBM, logs and Java profiles connected, I identified queries that failed to use indexes and inefficient execution plans, rewrote queries and added needed indexes. EKS status, log anomalies and Kotlin/Spring Boot execution remained part of the same investigation path.
    Result & scope
    Query and index improvements reduced average database load by over 30%, assessed across multiple operational metrics. Monitoring cost also fell to 80% of its previous level while diagnostic coverage expanded.
  7. Choosing cost-efficient infrastructureMatch compute choices to workload needs, checking cost and compatibility.
    Cost estimate
    ≈41% ↓Estimated hourly node cost
    Problem & constraints

    The cluster used seven m6i.xlarge nodes. Lowering cost required revisiting workload placement and instance composition; attempting to move every workload to ARM stalled when the Kafka connector migration failed.

    Application workloads and Kafka did not have the same architecture constraints. The cost-saving move still had to preserve a working connector environment, and instance-type changes brought migration downtime concerns.

    What I changed
    I adapted application builds for Graviton and placed Kafka pods in a separate AMD64 node group. Kafka affinity and tolerations constrained placement to its dedicated group. I changed the node mix to three r7g.xlarge and four t3a.medium nodes rather than requiring one architecture for every service.
    Result & scope
    Estimated node cost fell from $1.344/hour to $0.793/hour, about 41%. Kafka retained its working x86 environment while other application workloads moved to Graviton; the estimate describes this node configuration, not a company-wide billing reduction.

Historical results are from my production experience. Linked articles explain the implementation; local experiments and cost estimates have their own scope.

More work from this role
  1. Clinical rules, booking integration and legacy behavior

    I addressed repeated reads on underpowered hospital PCs, writes outside the API and databases that went offline with those PCs. Database-aware caching cut reservation responses from 2 seconds to 0.2 seconds. Fetching only changed fields reduced this API's client data transfer and Spring Boot memory use by 90% each; a separate delivery path decoupled bookings from hospital hours. For prescription migration, I built tooling to uncover amount and processing differences hidden behind matching API responses.

    View project details
    Product engineering10
    1. Smart Waiting

      Tried Redis Streams, then rebuilt hospital-keyed Pub/Sub around GraphQL/WebSocket subscriptions and coordinated connection cleanup.

    2. Smart Payment

      Handled insured, taxable and non-taxable amounts, earlier payments, discounts and hospital-specific truncation rules across approval and refund histories.

    3. Automatic Reception

      Connected device preferences to hospital receipt workflows, using a write lock for explicitly selected reservations and checks for existing waiting or visit links.

    4. Smart Chart

      Checked chart occupancy and batch-enriched prescriptions, including conditional medication rules and a UTF-8-safe legacy device identifier.

    5. Scheduler

      Combined permission checks, field-selective reservation edits, procedure assignments and updates to linked external booking platforms.

    6. Reservations

      Separated payment-pending bookings from completed reservations and derived appointment end times from procedure duration, alongside interval-based capacity synchronization.

    7. Smart Medical Questionnaire

      Reconstructed branching multilingual questionnaires from joined rows, batch-loaded text and images, and attached previous answers.

    8. Procedure Allocation

      Validated procedure and treatment-ticket IDs, linked clinical assignments, updated waiting state and invalidated the daily allocation cache.

    9. Open API · Hospital Integrations

      Queued database updates per hospital, checked connectivity and recorded applied versions before removing completed queue entries.

    10. Room & Staff Assignment

      Validated hospital-scoped assignments and staff roles, moved staff between room slots in a transaction and recorded assignment events.

  2. Cloud boundaries shaped by hospital workloads

    Per-hospital Hikari pools accumulated roughly 900 database-related threads in one pod. I designed hospital groups to separate DB connections, routing and releases, then mostly regrouped hospitals manually based on resource metrics and operational review. Reduced the average number of Hikari connection pools per pod from 2,000 to 400. I also consolidated monitoring in Datadog and calculated added and removed costs, reducing monitoring cost to 80% of its previous level.

    View project details
  3. Patient chat: message processing and delivery across instances

    Conversation history must persist, typing state is transient, and read status belongs to each user. I used these differences to separate storage and event processing from live delivery, connecting users across servers through hospital and conversation channels.

    View project details
  4. KPI Dashboards Across Affiliates & Data Pipelines

    I built a BigQuery and Prefect pipeline to make app/web usage trends and user behavior regularly visible. The dashboards combined DAU/MAU, session duration and page-level usage; after demonstrating their usefulness, I built them across all affiliates.

    View project details

Product engineering & cloud research

Engineering projects

PharmNote

I built a web and mobile platform for pharmacy field representatives, headquarters and suppliers to manage inventory, orders, collections and settlement. I designed and implemented the backend, web frontend, mobile app and AWS infrastructure to bring work previously scattered across paper ledgers and messaging into one system.

PharmNote’s web product catalog showing categories, base units, current prices, and activation status in a labeled demo workspace.
Web administration · Product catalog
PharmNote’s vehicle opening-inventory editor running in an iOS simulator, with explicit quantities and unit costs.
iOS app · Vehicle inventory

Recorded demo environments · August–September 2026

Cloud Orchestrator

I built a Kubernetes operations system to evaluate service quality alongside provider resource efficiency. Recovery, scaling and placement policies can make conflicting changes to shared resources, so I designed a central coordinator to validate proposals from eight roles and execute one change at a time. I persisted execution records to block retries of uncertain operations and separated policy decisions from outcome measurement. I built a baseline-versus-controller comparison setup across two local clusters and verified service scaling and workflow execution.

Cloud Orchestrator control overview showing eight roles, eight proposals, one unknown operation and unverified cloud contribution in a synthetic snapshot.
Control overview

Saved dashboard · Synthetic snapshot · September 2026

Recent writing

Notes from the build.

Read technical writing
Explore project journeys

Resume

I investigate root causes and build reliable, efficient backend services.

Resume

The stack behind the work.

Open skillset

Contact

Open to backend, platform, and infrastructure engineering opportunities.

ystc1247@gmail.com

DIRECT MESSAGE

Tell me what you are building.

Share the role, project, or engineering problem. I will reply to the email you provide.

View full screenshot

All Projects

SmartDoctor / Backend / Domain correctness

Clinical rules, booking integration and legacy behavior

KotlinSpring BootJPAQueryDSLSQL ServerGraphQLRedisDebeziumKafkaSQS

Problem & context

I addressed repeated reads on underpowered hospital PCs, writes outside the API and databases that went offline with those PCs. Database-aware caching cut reservation responses from 2 seconds to 0.2 seconds. Fetching only changed fields reduced this API's client data transfer and Spring Boot memory use by 90% each; a separate delivery path decoupled bookings from hospital hours. For prescription migration, I built tooling to uncover amount and processing differences hidden behind matching API responses.

Read the engineering story

Product engineering

Smart Waiting: A messaging model for every connected hospital display

Tried Redis Streams, then rebuilt hospital-keyed Pub/Sub around GraphQL/WebSocket subscriptions and coordinated connection cleanup.

Problem & context

Waiting-room displays connected to different servers and joined or left independently. When the initial Pub/Sub delivery did not work as expected, I tried Redis Streams.

Each server with displays for the hospital needed the update. Streams can support that broadcast too, but require managing read positions and retained history; a shared consumer group alone distributes work across consumers.

Engineering decisions
I returned to hospital-keyed Pub/Sub and rebuilt its subscription lifecycle. The final design focuses on live broadcast: Redis feeds local GraphQL/WebSocket subscribers, and registration and removal share one synchronization boundary.
Evidence & outcomes
Each server retains the hospital listener while local displays remain and removes it after the last disconnect. The implementation coordinates local connection changes without adding stream replay or consumer-group recovery to this notification path.
Smart Payment: A card approval still had to match the clinical ledger

Handled insured, taxable and non-taxable amounts, earlier payments, discounts and hospital-specific truncation rules across approval and refund histories.

Problem & context

Saving a card approval also required updating clinical receivables and preserving the accounting behavior of the legacy hospital system.

Prior payments, tax categories, discount order and hospital-specific truncation changed the amount that remained payable.

Engineering decisions
Worked on transaction-scoped approval/refund flows, separate amount calculations and history records, and MediCash integration; kept completion notifications separate from the hospital write response.
Evidence & outcomes
Approval and refund paths record clinical and card histories, adjust receivables and account for prior payments. Already-completed payments are rejected before approval persistence.
Automatic Reception: A kiosk check-in had to connect several clinical records

Connected device preferences to hospital receipt workflows, using a write lock for explicitly selected reservations and checks for existing waiting or visit links.

Problem & context

A kiosk check-in had to connect a reservation, clinical visit and waiting-room record while preserving existing hospital rules.

A selected reservation might already be linked to a visit; department, doctor and device settings also affected the transition.

Engineering decisions
Forwarded device preferences into the hospital receipt flow, locked explicitly selected reservations with PESSIMISTIC_WRITE, checked existing state and coordinated the visit/reservation/waiting updates.
Evidence & outcomes
The explicit-reservation path serializes access to the selected row and rejects an existing visit link; existing reserved waiting records have a separate transition path.
Smart Chart: A chart save had to respect the editing device and prescription rules

Checked chart occupancy and batch-enriched prescriptions, including conditional medication rules and a UTF-8-safe legacy device identifier.

Problem & context

Saving a chart required more than persisting the text entered on a tablet.

The hospital system tracked an editing device in a 50-byte field, while prescription codes carried their own billing and dispensing rules.

Engineering decisions
Checked the current device marker, truncated its identity at a valid UTF-8 boundary, batch-loaded prescription details and fetched exception settings only for relevant prescription classes.
Evidence & outcomes
The save request carries derived dispensing, exception and payment fields; a different recorded editing device causes an explicit rejection.
Scheduler: A calendar edit could also change an external booking

Combined permission checks, field-selective reservation edits, procedure assignments and updates to linked external booking platforms.

Problem & context

Hospital staff edited reservations that could already be linked to an external booking platform and procedure assignments.

An edit had to respect staff permissions, change only requested fields and preserve the rules of the originating platform.

Engineering decisions
Applied create/update permissions and explicit property lists in the hospital service, updated procedure assignments and checked linked bookings before forwarding their changes.
Evidence & outcomes
Scheduling follows the reservation’s origin and requested changes, with clinical procedure updates and external-platform calls handled in the same workflow.
Reservations: Payment and procedure duration changed what a booking meant

Separated payment-pending bookings from completed reservations and derived appointment end times from procedure duration, alongside interval-based capacity synchronization.

Problem & context

The booking platform needed counts for each time slot, while hospital reservations described start and end times.

Appointments could start between slot boundaries or span multiple slots; persisted counts also needed to reflect changed or removed bookings.

Engineering decisions
Rounded interval boundaries, counted each overlapping slot and reconciled derived counts against stored rows, inserting, updating and deleting entries as needed.
Evidence & outcomes
Booking integrations receive time-bucket counts derived from reservation intervals, with scoped reconciliation to remove obsolete count rows.
Smart Medical Questionnaire: A branching form had to be rebuilt from legacy rows

Reconstructed branching multilingual questionnaires from joined rows, batch-loaded text and images, and attached previous answers.

Problem & context

The product needed a structured questionnaire, but hospital queries returned repeated rows for questions, options and resources.

Each option could lead to another question or questionnaire; language-specific text, images and previous responses also belonged in the result.

Engineering decisions
Deduplicated questions and options, mapped branch targets, batch-loaded resources for the requested language and joined the customer’s previous responses.
Evidence & outcomes
The API assembles question structure, branch links, localized resources and prior answers into a form the client can render.
Procedure Allocation: One assignment crossed treatment, ticket and waiting records

Validated procedure and treatment-ticket IDs, linked clinical assignments, updated waiting state and invalidated the daily allocation cache.

Problem & context

A treatment allocation request could contain both directly booked procedures and treatments backed by a ticket.

The two record types used different identifiers and could already belong to an allocation; linked prescriptions and waiting state also needed updates.

Engineering decisions
Resolved both identifier families, rejected missing or already-allocated records, linked the allocation and applicable prescriptions, then updated waiting state and evicted the hospital’s daily cache.
Evidence & outcomes
The allocation flow connects the selected treatment records to clinical and waiting state; subsequent reads rebuild the evicted daily allocation view.
Open API · Hospital Integrations: A schema rollout depended on each hospital being reachable

Queued database updates per hospital, checked connectivity and recorded applied versions before removing completed queue entries.

Problem & context

Independent hospital databases were not always reachable when a schema update was queued.

A rollout had to address each hospital separately and distinguish a failed connectivity check from a completed version update.

Engineering decisions
Used a persistent hospital update queue, an hourly connectivity check and per-hospital update execution followed by applied-version recording.
Evidence & outcomes
A failed connectivity check leaves that hospital queued for a later pass; the successful path records applied versions and clears its queue entry.
Room & Staff Assignment: Moving a staff member changed two room assignments

Validated hospital-scoped assignments and staff roles, moved staff between room slots in a transaction and recorded assignment events.

Problem & context

Clinic operations needed to track which room, patient and staff roles were assigned together as work moved between rooms.

Doctors, consultants and assistants occupied different slots, and an existing assignment affected whether a new assignment or transfer was valid.

Engineering decisions
Checked ongoing assignments and staff types, removed the source role during a transfer, checked the destination role and saved the destination with event logs in a local transaction.
Evidence & outcomes
The staff-transfer path updates both assignments and records removal/addition events; an occupied destination role causes an explicit rejection.
2 seconds → 0.2 seconds.
Problem & constraints

Clinics running the C# EMR and database on underpowered PCs complained about sluggish reservation boards and relied on manual refresh. Repeated reads across a reservation flow involving roughly 50 tables created CPU and memory pressure; most API delay was in database queries and fetching.

Legacy programs also wrote to hospital databases, so API-only cache invalidation could miss changes. I tried CDC, but maintaining connectors across 1,000 database hosts was unmanageable and the Kafka–Debezium connections were unstable.

What I changed
I replaced the hospital-host CDC approach with database triggers that advance a cache version when relevant columns change. The API batch-fetches only required DTO fields, assembles results by key, and applies staff-specific filters after the cache lookup. Separately, I compared packet timings and network paths to isolate extra query-fetch delay in an NCP VPC, then led evidence-based technical meetings with NCP engineers.
Result & scope
Fetching only changed fields cut this API's client data transfer and Spring Boot memory use by 90% each; response time fell from 2 seconds to 0.2 seconds. I drove the separate network investigation through NCP's cause confirmation and completed fix.
Read the engineering story
Test the financial behavior, not just the API response
Problem & constraints

A prescription could save successfully yet produce different patient charges if rounding, tax or night/holiday surcharge rules changed. The C#-to-Kotlin migration needed evidence that calculations and processing still matched the legacy system.

Calculation rules were spread across C# branches and SQL. Matching API responses could conceal different amounts or writes, so verification had to check operation order and changes to prescriptions with existing receipts.

What I changed
I built a comparison back office, captured executed SQL and bound values from both implementations, and compared their operation order. I traced differences through calculation branches and queries, corrected the implementation, and repeated verification across successive test waves.
Result & scope
The initial 450-case wave passed after corrections. Payment-related cases followed separately; the comparison made differences inspectable rather than relying on response equality.
Read the engineering story
CDC and Debezium: durable delivery to offline hospital databases
Problem & constraints

Online bookings continued after hospital PCs and their databases shut down. Accepting a booking and applying it to the hospital database could not depend on the same live request.

Delivery intent had to remain after the request ended, including when external dispatch failed after the database write. Offline hospitals needed a different retry policy from other processing failures. This CDC source was the central reservation-platform outbox, not connectors on 1,000 hospital hosts.

What I changed
I persisted delivery work in the central outbox and used Debezium CDC to publish committed inserts to Kafka. A consumer dispatched hospital-grouped SQS messages or the specified API work, then recorded the handled state and acknowledged the Kafka event. This separated capturing committed work from hospital-specific delivery.
Result & scope
Kept hospital delivery work in SQS until successful handling. Offline databases followed a delayed retry path; repeatedly failing messages moved to a DLQ with diagnostic notification. Booking acceptance remained separate from destination availability and failure handling.
Read the engineering story
SQL Server JDBC: trace a VARCHAR index-use problem to string binding
Problem & constraints

During the Kotlin/Spring Boot migration, slow SQL Server lookups were not using the intended VARCHAR index. Query-plan comparisons traced the access-path change to string parameters sent as Unicode.

Existing hospital programs depended on different physical column definitions. I could not change every schema, and changing parameter binding alone would not fix the separate getNString getter-conversion rejection.

What I changed
I set sendStringParametersAsUnicode=false for ordinary strings while retaining selected @Nationalized mappings. I traced Hibernate into JDBC internals and implemented a Spring @PostConstruct hook using reflection/Unsafe to add NCHARACTER to the CHARACTER/LONG_CHARACTER getter rules and conversionMap.
Result & scope
Corrected ordinary-string binding without changing hospital tables and made the pinned driver's getter accept VARCHAR → NCHAR reads. Database CPU usage fell 20%, and execution time fell 80% for queries that had missed their intended indexes. The getter workaround depended on that version's private driver internals.
Read the engineering story
Separate reservation responses from follow-up work without losing attribution
Problem & constraints

Reservation changes triggered external synchronization and history recording. The response path needed to avoid waiting for that follow-up work to finish.

History still needed the initiating user after the request ended. Slower history processing and user information on reused worker threads required separate controls.

What I changed
I scheduled follow-up work after the reservation transaction committed, carrying request and authentication information into the worker. Slower history tasks use separate execution resources, and custom user information is cleared whether the task succeeds or fails.
Result & scope
Reservation responses do not wait for follow-up completion, while history processing retains the user and IP. Custom request information is cleared from reused threads even on failure.
Read the engineering story

SmartDoctor / Tenant isolation / Cloud operations

Cloud boundaries shaped by hospital workloads

EKSHelmArgoCDKEDAIstioDatadogPrometheus

Problem & context

Per-hospital Hikari pools accumulated roughly 900 database-related threads in one pod. I designed hospital groups to separate DB connections, routing and releases, then mostly regrouped hospitals manually based on resource metrics and operational review. Reduced the average number of Hikari connection pools per pod from 2,000 to 400. I also consolidated monitoring in Datadog and calculated added and removed costs, reducing monitoring cost to 80% of its previous level.

Read the engineering story
Hospital groups to distribute Hikari pools and rebalance pod load
Problem & constraints

After the ECS-to-EKS migration, per-hospital Hikari connection pools still accumulated roughly 900 database-related threads in one pod. Its 1 GB heap used about 900 MB even after GC.

I needed to change how each pod retained pools for multiple hospitals. Usage also differed by hospital, so fixed group membership could leave a few pods carrying most of the load.

What I changed
I proposed and implemented hospital groups so each pod connected to its assigned hospitals. I aligned Istio routing and Helm/ArgoCD releases with those groups, alongside group-specific scaling and shared tracing.
Result & scope
When heavy hospitals concentrated load on particular pods, I reviewed resource metrics with operations to distinguish temporary spikes from sustained load, then mostly regrouped hospitals manually. This distributed hospital pools and load across pods. Reduced the average number of Hikari connection pools per pod from 2,000 to 400.
Read the engineering story
Datadog migration and query tuning reduced average database load by over 30%
Problem & constraints

Distinguishing EKS resource problems from database queries or application execution meant following information across Prometheus, Grafana, OpenTelemetry and Jaeger. Investigations needed a connected path from infrastructure anomalies to code execution.

Broader APM, DBM, log and Java-profile coverage had to fit within the existing monitoring budget. I needed to calculate both new charges and costs removed from the existing setup to evaluate adoption and plan the migration.

What I changed
I led vendor discussions, cost analysis and the migration. With APM, DBM, logs and Java profiles connected, I identified queries that failed to use indexes and inefficient execution plans, rewrote queries and added needed indexes. EKS status, log anomalies and Kotlin/Spring Boot execution remained part of the same investigation path.
Result & scope
Query and index improvements reduced average database load by over 30%, assessed across multiple operational metrics. Monitoring cost also fell to 80% of its previous level while diagnostic coverage expanded.
Workload-aware node placement and selective Graviton migration
Problem & constraints

The cluster used seven m6i.xlarge nodes. Lowering cost required revisiting workload placement and instance composition; attempting to move every workload to ARM stalled when the Kafka connector migration failed.

Application workloads and Kafka did not have the same architecture constraints. The cost-saving move still had to preserve a working connector environment, and instance-type changes brought migration downtime concerns.

What I changed
I adapted application builds for Graviton and placed Kafka pods in a separate AMD64 node group. Kafka affinity and tolerations constrained placement to its dedicated group. I changed the node mix to three r7g.xlarge and four t3a.medium nodes rather than requiring one architecture for every service.
Result & scope
Estimated node cost fell from $1.344/hour to $0.793/hour, about 41%. Kafka retained its working x86 environment while other application workloads moved to Graviton; the estimate describes this node configuration, not a company-wide billing reduction.
Replicas increased with uptime instead of traffic
Problem & constraints

Memory-based autoscaling added replicas as JVM processes stayed alive, without corresponding growth in traffic.

Switching to CPU also required examining startup spikes and how pod scaling interacted with node provisioning.

What I changed
I changed HPA to CPU, profiled application startup, and investigated rollout behavior alongside the move to Karpenter.
Result & scope
The autoscaling policy was changed from memory to CPU. Profiling and subsequent rollout investigations separated application startup load from sustained operating load.
Encryption required a production database migration
Problem & constraints

Existing RDS databases needed an encryption migration while applications still depended on their schemas and generated keys.

The DMS attempt exposed schema, auto-increment and foreign-key issues. A separate VPC with overlapping CIDRs also complicated connectivity.

What I changed
I worked through the migration and compatibility issues across the target databases instead of treating copied rows as proof of readiness.
Result & scope
The production databases in the migration scope were moved to the encrypted environment.
Tracing database latency to an NCP network fix
Problem & constraints

During the reservation-performance investigation, some hospital databases hosted on Naver Cloud Platform took up to one second longer to fetch query results.

Hospitals used different hosting environments, so application timings alone could not explain why the delay affected only some groups.

What I changed
I compared packet timings and network paths, found the delay concentrated in a particular NCP VPC environment, and presented the comparisons in technical meetings with NCP engineers.
Result & scope
NCP confirmed the cause and implemented a fix after reviewing the evidence in technical meetings.
Read the engineering story

Socket.IO / Kafka / Healthcare CRM

Patient chat: message processing and delivery across instances

Socket.IOKafkaRedisRedissonTranslation APIs

Problem & context

Conversation history must persist, typing state is transient, and read status belongs to each user. I used these differences to separate storage and event processing from live delivery, connecting users across servers through hospital and conversation channels.

What I built

  • Keyed message events by conversation and routed them to hospital and conversation participants, separating message processing from individual socket lifecycles.
  • Paged stored history by message ID and delivered typing state separately. Per-user last-read positions track read status independently of stored conversation history.
  • Stored Korean and English message content and added translation for bilingual conversations, preserving translated content for subsequent history reads.

SmartDoctor / Scheduled monitoring / Product analytics

KPI Dashboards Across Affiliates & Data Pipelines

PythonPrefectBigQueryAurora MySQLDatadogBackfill

Problem & context

I built a BigQuery and Prefect pipeline to make app/web usage trends and user behavior regularly visible. The dashboards combined DAU/MAU, session duration and page-level usage; after demonstrating their usefulness, I built them across all affiliates.

What I built

  • Scheduled Prefect jobs to query and aggregate app/web data in BigQuery roughly hourly and update Datadog KPI dashboards.
  • Built dashboards combining DAU/MAU trends, session duration and page-level usage, then expanded them across all affiliates.
  • Implemented KPI-history replay, backfill and dashboard-update tooling. Also automated hospital-database checks for expensive queries, CPU, memory and fragmentation.

Engineering project / B2B SaaS / Web & mobile

PharmNote: Pharmacy Sales & Operations Platform

KotlinSpring BootPostgreSQLReactReact NativeAWSTerraform
PharmNote’s web product catalog showing categories, base units, current prices, and activation status in a labeled demo workspace.
Recorded demo environments · August–September 2026

Problem & context

I built a web and mobile platform for pharmacy field representatives, headquarters and suppliers to manage inventory, orders, collections and settlement. I designed and implemented the backend, web frontend, mobile app and AWS infrastructure to bring work previously scattered across paper ledgers and messaging into one system.

Visit PharmNote

What I built

  • Mapped vehicle sales, central-stock fulfillment and supplier direct shipments to separate stock movements and settlement parties. A shared sales screen could not imply the same accounting effect for every route.
  • Separated purchase cost, internal dispatch price and pharmacy sale price to calculate company and representative profits independently. Preserved transaction-time values and linked returns and reversals to the original sale so later catalog changes do not revalue historical records.
  • Made visit completion a single transaction covering sales, returns, optional collections, stock and receivables, keeping the field workflow and its accounting effects together.
  • Scoped access through tenant-bound authentication, role and ownership checks, and PostgreSQL row-level policies; separated supplier views from administrator cost and profit data.
  • Persisted mobile drafts before versioned submission and retained uncertain collection retries, so interrupted fieldwork can be resumed without treating a missing response as a failed payment.

Python / Kubernetes / Policy Coordination / Execution Verification

Cloud Orchestrator: Kubernetes Operations Automation

PythonKubernetesPrometheusDockerNumPy
Cloud Orchestrator control overview showing eight roles, eight proposals, one unknown operation and unverified cloud contribution in a synthetic snapshot.
Saved dashboard · Synthetic snapshot · September 2026

Problem & context

I built a Kubernetes operations system to evaluate service quality alongside provider resource efficiency. Recovery, scaling and placement policies can make conflicting changes to shared resources, so I designed a central coordinator to validate proposals from eight roles and execute one change at a time. I persisted execution records to block retries of uncertain operations and separated policy decisions from outcome measurement. I built a baseline-versus-controller comparison setup across two local clusters and verified service scaling and workflow execution.

Read the engineering story

What I built

  • Assigned ownership for recovery, capacity, admission, service sizing, placement and workflow dispatch; diagnosis and interference analysis remain advisory. Each action can invalidate the next decision’s assumptions, so I chose an observe–validate–execute loop with one mutation at a time.
  • The Referee checks observation freshness, authority, SLOs and budgets before execution. I persisted intent before mutation and validated state revisions and idempotency keys at the gateway to block repeat execution when the outcome is uncertain.
  • Verified real service scaling and DAG execution in local Kubernetes. The controller and collector have read-only access; a scoped gateway owns mutations, and the learning process receives no cluster credentials.
  • Separated baseline and controller clusters and collected request and CPU metrics independently under matched load. Deterministic policies remain the default; the optional learned model ranks only feasible proposals and requires comparison evidence before activation.

Personal experiment / Market-data pipelines

Quant Trading: Personal Toy Project

PythonParquetscikit-learn

Problem & context

A personal toy project for exploring reproducible market-data pipelines and cautious strategy evaluation.

What I built

  • Explored Databento data preparation, chronological splits and no_trade baselines.

SwiftUI / Runtime Safety / Codex MCP

DevBerth: macOS Development Service Manager

SwiftSwiftUISwiftDataMCPDockermacOS
DevBerth’s native runtime view showing local listeners and container services.
Recorded app capture · July 2026

Problem & context

I built a native macOS app to inspect local ports, processes and Docker services, manage project services and restore workspace sessions. Its MCP integration lets Codex use the same application-owned controls, with fresh ownership checks before an action.

Read the engineering story

What I built

  • Started with repeated port-conflict checks across lsof, ps and Docker. Built a shared view of running services, reviewed launch definitions, project dependencies and saved workspaces; kept observation separate from permission to stop or restart a service.
  • Kept monitoring, persistence and lifecycle control in the native app. The MCP helper routes Codex requests to that same authority, with version checks and single-use previews for destructive actions.
  • Activity Monitor revealed sustained CPU use after the window closed. The initial suspect was process discovery; Instruments instead exposed substantial main-thread SwiftUI and AttributeGraph work, and counters connected timestamp-only snapshot changes to repeated publication and persistence.
  • Preserved observation timestamps for freshness while comparing meaningful runtime state separately. Unchanged-snapshot tests went from 30 transactions and 3,460 persistent-history changes per minute to zero writes; one cancellable monitor loop coalesced overlapping refresh requests.
  • Used actual AppKit visibility and occlusion to adjust polling, batched process and Docker queries, and suppressed unnecessary hidden-window publication. Idle observations can be up to 30 seconds old; stop and restart still require fresh identity and ownership checks.
  • Recorded matched Release comparisons on one Mac: with the main window and menu popover closed, each 901-second run showed average CPU falling from 69.2% to 0.118%. The historical full-app suite passed 210 tests; the detailed article retains measurement conditions and remaining foreground hitches.

showmethesanggwon.com / Backend & Frontend / Proptech

Trade-Area Analysis & Property Recommendations

KotlinSpring BootReactTypeScriptPostgreSQL

Problem & context

Built a proptech product to help prospective founders evaluate Seoul trade areas and shortlist commercial properties through score-based analysis, map workflows and recommendation APIs.

What I built

  • Developed an XGBoost-based AI model. Built backend and frontend surfaces for map-based trade-area analysis, property search, Top 3 recommendations, saved analyses, and detailed listing inspection.
  • Implemented API flows around analysis creation, polling and SSE progress, property filtering, structured prompt search, horizon survival scores, score explanations, and metric references.
  • Shaped product UX across Analyze, property listings, Detail, History, shortlist/compare, budget filters, and natural-language property exploration; the project went on to win the 2026 Seoul Big Data Utilization Contest Grand Prize.

Small university project / Mobile

Semo: Travel Companion App

KotlinSpring BootReact Native

Problem & context

A small mobile project for finding travel companions, planning trips, and chatting.

What I built

  • Built Kotlin/Spring Boot APIs and React Native flows; received the Excellence Award at Kyung Hee University’s 2026 SemoThon.

SWMaestro / Product Launch / Applied AI

Korean Learning Platform For Foreign Learners

JavaSpring BootFlaskOpenAInginx

Problem & context

Built a Korean-learning product through SWMaestro, covering ideation, planning, backend development, deployment, and app launch.

What I built

  • Developed video-processing flows for subtitle-based learning and speaking practice.
  • Used NLP and OpenAI APIs to extract vocabulary examples and usage context from learning material.
  • Owned product execution across backend APIs, Flask services, nginx deployment, and launch preparation.

Contracts / Observability / Integration Reliability

Reliability Tooling & Developer Productivity

OpenAPIFeignSQSKafkaRedisDatadogServiceMonitor

Problem & context

Turned repeated integration friction into explicit platform patterns across backend, messaging, observability, and deployment repos rather than leaving each issue as a local fix.

What I built

  • Standardized hospital-scoped request context through argument resolvers, Feign auth-token clients, Secrets Manager and Parameter Store configuration, and multi-module application/domain boundaries.
  • Improved operational visibility with Swagger/OpenAPI customizers, exception reason docs, request/response logging, Slack error routing, Datadog tracing/metrics, ServiceMonitor coverage, and Prometheus/Grafana manifests.
  • Hardened async and integration paths around SQS, Kafka/Debezium, Redis/Redisson, KEDA autoscaling, PDB/HPA resilience, and transactional facades for payment, reservation, receipt, and allocation flows.

Go / React / PostgreSQL / Experiment Replay

PostgreSQL Consistency Lab: Concurrency & Observability

GoReactTypeScriptPostgreSQLSSEDocker
PostgreSQL Consistency Lab replaying a completed queue workload, with a timeline and recorded metrics.
Local app capture · September 2026

Problem & context

Built a local database lab that connects reproducible concurrency scenarios to a React observability workspace, backed by a Go API and PostgreSQL.

Read the engineering story

What I built

  • Connected transaction actors, lock inspection, query plans, workload experiments, and saved replays through a shared evidence timeline.
  • Designed monitoring views that distinguish current gauges, interval rates, cumulative counters, and unavailable evidence.
  • The local application runs against PostgreSQL 16; its engineering article documents the scenarios and evidence boundaries.

Skillset

Backend, cloud, data, observability, ML, and frontend tools used across production systems and research pipelines.

Backend

Kotlin

Java

Spring Boot

GraphQL

Hibernate

WebSocket

Cloud

AWS

EKS

Kubernetes

Terraform

Helm

ArgoCD

Istio

GitHub Actions

Data

PostgreSQL

SQL Server

Redis

Kafka

Debezium

BigQuery

Python

Observability

Prometheus

Grafana

Datadog

Rancher

ML

Python

XGBoost

scikit-learn

Ray

Optuna

Polars

Pandas

NumPy

PyArrow

Feature Engineering

Frontend

React

TypeScript

React Native

Resume

Backend & Cloud Systems Engineer

I investigate root causes and build reliable, efficient backend services.

Experience

SmartDoctor · Backend Researcher

Jan 2024 - Feb 2026. Cut reservation responses from 2 seconds to 0.2 seconds. Fetching only changed fields reduced this API's client data transfer and Spring Boot memory use by 90% each. Led separate network debugging and NCP meetings through the provider's fix. Compared executed SQL, bound values and operation order during C# → Kotlin prescription migration; the initial 450-case wave passed after corrections. Built Debezium delivery so bookings could be accepted while hospital databases were offline. Corrected JDBC string binding and NCHAR reads, reducing database CPU usage by 20% and execution time by 80% for queries that had missed their intended indexes. Built EKS hospital-group releases. Reduced the average number of Hikari connection pools per pod from 2,000 to 400. Datadog-led query and index tuning reduced average database load by over 30%; monitoring cost fell 20%. Expanded BigQuery/Prefect KPI dashboards across all affiliates.

Education

Kyung Hee University

B.S. in Computer Engineering, Software Convergence College. Expected graduation in Feb 2027.

Program

Software Maestro 14th Cohort

Selected for the national software talent program in 2023 and launched a Korean-learning product through an end-to-end team project.

Achievements & Awards

Grand Prize

2026 Seoul Big Data Utilization Contest, Grand Prize

Seoul Metropolitan Government

University Excellence Award

Kyung Hee University 2026 SemoThon

Kyung Hee University

Program

Software Maestro 14th Cohort

Ministry of Science and ICT

Education

Campus Algorithm / Backend Training

Kyung Hee University

University Award

KHU Autumn Team Programming Contest, Excellence Award

Kyung Hee University

Contest

shake! Kyung-In Regional Programming Contest, 10th Place

Kyung-In Regional Programming Contest

University Award

KHU Autumn Team Programming Contest, Excellence Award

Kyung Hee University

University Award

KHU CTF Security Contest, Excellence Award

Kyung Hee University

University Award

KHU Spring Programming Contest, Bronze Award

Kyung Hee University

Additional Credentials

TOEIC 975

ETS

Korean / English

Language

About

I work on backend systems where slow requests, legacy data and unreliable connections meet. My focus is finding the constraint behind a problem and choosing a fix that holds up in operation.

Experience

SmartDoctor · Backend Researcher

Jan 2024 - Feb 2026. Cut reservation responses from 2 seconds to 0.2 seconds. Fetching only changed fields reduced this API's client data transfer and Spring Boot memory use by 90% each. Led separate network debugging and NCP meetings through the provider's fix. Compared executed SQL, bound values and operation order during C# → Kotlin prescription migration; the initial 450-case wave passed after corrections. Built Debezium delivery so bookings could be accepted while hospital databases were offline. Corrected JDBC string binding and NCHAR reads, reducing database CPU usage by 20% and execution time by 80% for queries that had missed their intended indexes. Built EKS hospital-group releases. Reduced the average number of Hikari connection pools per pod from 2,000 to 400. Datadog-led query and index tuning reduced average database load by over 30%; monitoring cost fell 20%. Expanded BigQuery/Prefect KPI dashboards across all affiliates.

Education

Kyung Hee University

B.S. in Computer Engineering, Software Convergence College. Expected graduation in Feb 2027.

Program

Software Maestro 14th Cohort

Selected for the national software talent program in 2023 and launched a Korean-learning product through an end-to-end team project.

Projects with backend depth and product context.

SmartDoctor / Backend / Domain correctness

Clinical rules, booking integration and legacy behavior

I addressed repeated reads on underpowered hospital PCs, writes outside the API and databases that went offline with those PCs. Database-aware caching cut reservation responses from 2 seconds to 0.2 seconds. Fetching only changed fields reduced this API's client data transfer and Spring Boot memory use by 90% each; a separate delivery path decoupled bookings from hospital hours. For prescription migration, I built tooling to uncover amount and processing differences hidden behind matching API responses.

View project details

SmartDoctor / Tenant isolation / Cloud operations

Cloud boundaries shaped by hospital workloads

Per-hospital Hikari pools accumulated roughly 900 database-related threads in one pod. I designed hospital groups to separate DB connections, routing and releases, then mostly regrouped hospitals manually based on resource metrics and operational review. Reduced the average number of Hikari connection pools per pod from 2,000 to 400. I also consolidated monitoring in Datadog and calculated added and removed costs, reducing monitoring cost to 80% of its previous level.

View project details

Socket.IO / Kafka / Healthcare CRM

Patient chat: message processing and delivery across instances

Conversation history must persist, typing state is transient, and read status belongs to each user. I used these differences to separate storage and event processing from live delivery, connecting users across servers through hospital and conversation channels.

View project details

Search writing

Search across titles, article text, and tags.