Resume

Last updated: 2026-05-13

Backend engineer for the past 3 years, with a long infrastructure background underneath. Operator-Engineer who builds, ships, and runs systems end-to-end. Writes Rails / Python API backends as daily work, while owning AWS / IaC / data infrastructure / WAF tuning on the side. Has accumulated 323 personal projects over 9 years, all running in production with notification-based monitoring, and currently embeds Claude Code / MCP / AI agents deep into daily development workflows to produce always-on serverless systems on an "Observe → Notify → Automate" pattern.

Highlights

What I bring to the table, framed for CTOs and tech leads:

Where I fit

A good fit when:

• You need someone to lead Rails / Python API backend development as the primary role
• You want a backend engineer who can also own IaC, data infrastructure, and WAF operations when needed
• You want to embed AI / Claude Code / MCP into engineering workflows and have someone spread it inside the org
• You need someone to stand up a new product end-to-end from zero
• You want a person who can evaluate and adopt new tech stacks early with low risk
• You need a backend-centered generalist who reaches into frontend, infrastructure, and LLM layers as required

Probably not the best fit when:

• You need a single-stack deep specialist (e.g., pure frontend or pure data engineering)
• You evaluate primarily on large-scale SRE incident response as your main hiring signal
• You're hiring a full-time dedicated SRE / infrastructure engineer — that's a background skill for me, not the current primary role

Profile

Engineer whose primary work for the past 3 years has been Rails / Python API backend development, with a long infrastructure operations background underneath (AWS / Terraform / data infrastructure / WAF). Not just a backend engineer — I can also own IaC + observability + data pipelines as a single stack. On top of that I wire applications to Discord / LINE / Slack notifications to produce always-on serverless systems following an "Observe → Notify → Automate" pattern. My stance is "solve my own problems with my own code" — I keep a steady stream of personal repositories where I probe new domains with small prototypes.

Recent activity (by the GitHub numbers)

Stance

• Ship the smallest thing that works, then iterate
• Go deep on tools I use weekly rather than broad on tools I touch once
• Apply "Observe → Notify → Automate" to both work and personal life
• Use personal projects as a testbed, then promote what works to production at work
• Invest in embedding AI into the development workflow itself, not just using it as an assistant

Current role

Full-stack engineer at a real-estate tech (PropTech) B2B SaaS company. Company and product names are anonymized in this document.

I rotate across the following surfaces, driven by ticket-based work:

• Rails-based API backend (core service data model and business logic)
• Next.js end-user frontend application
• Next.js admin console (internal operations tool)
• Embedded widget (JS bundle injected into customer sites)
• Chatbot for customer sites (with LLM integration)
• Referral program / alliance integration features

Skills

Listed below: languages and frameworks I write weekly across work and personal projects.

Languages

Backend 〔primary focus for the past 3 years〕

Where I've spent the most time recently. I work on API backends in both Rails and Python and ship modern, production-grade configurations.

• Rails 7.x / 8.x
  • Primary stack at work. Designed, implemented, and operated multiple API backends.
  • Solid Queue / Solid Cable / Solid Cache modern setup
  • RSpec + FactoryBot, N+1 detection, error tracking, jbuilder
  • rubocop-rails-omakase / Brakeman / bundler-audit for static analysis and vuln scanning
• Python server-side
  • FastAPI / AWS Chalice / AWS Lambda (Python) for APIs and batch jobs
  • Pydantic for domain modeling, dependency injection, type-driven design
  • uv + ruff + mypy + pytest toolchain
• Next.js API Routes for thin TypeScript APIs / BFF layers
• Data stores: PostgreSQL (index design, JSONB, window functions), Redis (cache + job queue)
• API design: REST, JSON Schema, contract-driven, error handling, auth, rate limiting, webhook receivers
• Modern engineering: types + tests + lint + format + static analysis enforced in CI

Infrastructure / Cloud / SRE 〔long-running background〕

The substrate under the backend work. I've operated AWS + IaC for a long time and own CI/CD, scheduled jobs, notification hooks, and observability on top.

• AWS (daily, work + personal)
  • Compute: Lambda, EC2 + Docker, ECS, Fargate, Lightsail (Docker Compose)
  • Edge / delivery: CloudFront, S3 (static sites + assets), Route 53
  • API / events: API Gateway, EventBridge (cron triggers), SQS, SNS
  • Data: RDS (PostgreSQL), ElastiCache (Redis), DynamoDB
  • Auth / network: IAM, VPC, Security Groups, Secrets Manager
• IaC
  • Terraform as the workhorse. I keep reusable templates for Lambda / API Gateway / CloudFront + S3 / EC2 + Docker / EventBridge cron and pull them into new projects.
  • State on S3 + DynamoDB locking.
• Containers
  • Docker / Docker Compose for daily use
  • AWS Chalice for the full lifecycle of Python serverless APIs
• CI / CD
  • GitHub Actions for test / lint / build / deploy / scheduled jobs / notifications
  • This very repo auto-deploys to Cloudflare Pages on push to main
• Observability / notifications
  • Always-on serverless notifications to Discord / LINE / Slack across many personal projects
  • CloudWatch Logs / Metrics, log forwarding, X-Ray when needed
• Security operations / WAF
  • AWS WAF / Cloudflare WAF: enabling managed rules and tuning out false positives, designing IP sets / rate-based rules / custom rules
  • WAF logs → CloudWatch Logs / S3 → Athena aggregation → detection loop
  • Custom rules informed by OWASP Top 10, ongoing tuning against operational false positives
• Cloudflare
  • Cloudflare Pages (static hosting), Workers, Cloudflare WAF
• Learning: Kubernetes (21 starred repos, working toward production use)

Data infrastructure / workflows 〔long-running production area〕

Years of production experience in batch / ETL / workflow orchestration:

• digdag: declarative .dig files for dependency-aware jobs, scheduled execution, retry control, error handling, SLA monitoring
• embulk: bulk data transfer between heterogeneous sources (RDB / CSV / API / S3 / BigQuery), schema reconciliation, incremental loads
• Apache Airflow: Python-based DAG design, Sensor / Operator composition, Executor configuration
• Analytical SQL / mart design: window functions / CTEs for transformations, data integrity checks, idempotent design
• Job operations: Slack / Discord notifications on failure, SLA-breach detection, recovery runbooks, re-run design

Web frontend

• React 18 / 19, Next.js 14–16 (App Router / Server Components / Server Actions)
• Tailwind CSS v4, shadcn/ui, Radix UI, SWR, Zod, react-leaflet
• Astro 5 (blogs / LPs / this resume site itself)
• Vitest, Testing Library

LLM / AI / Agents

• Anthropic SDK (Claude) / OpenAI SDK directly in applications
• LangChain / CrewAI for small-scale agent prototypes
• Whisper (OpenAI / @remotion/openai-whisper) for speech-to-text
• Google Cloud Text-to-Speech for pronunciation content
• MCP (Model Context Protocol) servers — built from scratch
• Claude Code hooks, skills, and subagents embedded in the dev workflow to automate code review, PR drafting, and ticket creation

Video / content automation

• Remotion 4.x for video generation pipelines
• Pipeline: text → TTS → Whisper word-level timestamps → React caption rendering → mp4 → social-media post
• Templates externalized to YAML / JSON for data-driven production

Browser extensions & automation

• Chrome / Firefox extensions (Manifest V3) using WXT and Plasmo
• Playwright for browser automation and end-to-end testing
• Built UI for multi-account switching, container-tab management, Page Visibility API interception

Security research / traffic analysis / Android rooting 〔personal sandbox〕

I'm drawn to observing web and mobile app behavior at the network and OS layer. Things I maintain on personal time:

• mitmproxy: HTTPS MITM setup to inspect, tamper with, and record traffic from browsers and mobile apps in real time
• Android rooting / Magisk: Pixel devices rooted via fastboot + Magisk to run analysis tools like Frida. Post-factory-reset Magisk setup reproducible as a one-command Python script + Markdown runbook (kept as a personal repo)
• Mobile UI automation: Driving native apps via ADB / uiautomator2 / Appium / Maestro to acquire tokens and reproduce behaviors
• APK / IPA inspection: Workflow of observing app traffic with mitmproxy + Frida, then implementing a homegrown client against the same API
• Web traffic interception: Accumulated patterns for Manifest V3 extensions, Page Visibility API overrides, and container tab isolation — rewriting browser behavior when needed

I've never had security research as my day job, but these directly inform detecting suspicious traffic early, investigating in-house client API surfaces, and noticing vulnerabilities in existing services.

Mobile / desktop

• Expo / React Native: feature validation in personal projects
• Flutter (Dart): prototypes for learning apps
• Tauri, Electron, Nextron: purpose-built browser experiments

Architecture patterns I use repeatedly

Stable templates I reach for again and again across personal and work projects:

Interest areas

Outside of work, I build small products driven by my own day-to-day problems. The common thread is the same "Observe → Notify → Automate" loop. The areas below are ordered by technical depth (count is shown but is not the same as priority — the deepest work is at the top):

A. Where I've gone deepest (the CTO-relevant core)

1. AI agents / LLM tools 〔~13 personal + 113 starred〕

Continuous prototyping with Anthropic / OpenAI / LangChain / CrewAI. Lately I'm focused on embedding Claude Code as a CLI / hook / skill / MCP layer inside the development workflow — code review, PR drafting, and ticket creation are all automated. Recent stars include claude-trading-skills, claude-skills (245+), microsoft/agent-framework, microsoft/autogen, and stagehand — the recurring theme is making AI agents first-class citizens in engineering orgs.

2. Infrastructure / IaC template maintenance 〔~10 personal + 78 starred〕

Background infrastructure area (see "Infrastructure / Cloud / SRE" above), continuously refreshed in a personal context. I keep rebuilding minimal-config samples of Terraform / Lambda / Chalice / Lightsail / Docker Compose, absorbing new AWS features, Cloudflare Pages, and HashiCorp Vault as they ship. New projects start from these templates.

3. US equity market screening 〔~26 personal〕

Multi-strategy screening over the S&P 500 — technical indicators, moving-average touches, earnings, market sentiment — feeding Discord / LINE notifications. Built on Python + AWS Lambda with yfinance / OpenBB / pandas / ta / Pydantic. I'm now experimenting with AI-augmented analysis (recent stars: anthropics/financial-services).

4. Video / content automation pipelines 〔~5 personal〕

Remotion + Google TTS + Whisper + LLM together to mass-produce learning videos and market-commentary clips. Templates externalized to YAML / JSON for data-driven production. The "GenAI × media at scale" axis.

5. Browser automation / Chrome & Firefox extensions 〔~7 personal + 15 starred〕

Writing extensions in WXT / Plasmo / Manifest V3, observing web behavior with Playwright / Stagehand. Subtitle translation, container-tab management sidebar, background-video persistence, multi-account isolation — I enjoy bending browser UX to my own preferences.

6. Security research / mitmproxy / Android rooting 〔few personal〕

Sandbox for "observing traffic" and "removing OS restrictions": running mitmproxy MITM for HTTPS, maintaining Magisk-rooted Pixel devices, automating mobile UI via ADB / Appium / Maestro, and observing an APK's API surface before writing a homegrown client. Reproducibility is part of the design — post-factory-reset Magisk setup is reproducible from a single Python script.

B. High-volume experimentation grounds

7. Web / browser-automation testbed (social-media surface) 〔~60+ personal〕

My largest category by count. A broad sandbox for multi-account workflows, Chrome / Firefox extensions, Playwright / ADB / Appium / Maestro, API client wrappers, container isolation, purpose-built browsers — essentially every automation technique across web × extension × mobile × desktop. Highlight #5 (cross-domain agility) and the browser-automation / security-research skills above all came out of here.

8. Language-learning platforms (Korean / Chinese / multilingual) 〔~36 personal〕

As a learner of Korean and Chinese, I build the materials, apps, and content I want. Vocabulary databases, curriculum integrity checkers, TTS + Whisper for pronunciation content, Remotion for explanation videos, mobile / web learning UI. My strongest area for content pipelines.

C. Private interests (less generalizable)

9. Quality-of-life utilities 〔~9 personal〕

Restaurant maps, sports-court availability monitors, park-info collectors, restaurant-genre review aggregators — things I actually use every week. Doubles as a sandbox for modern web stacks (Next.js + Leaflet / React-Leaflet, Tailwind v4, Vitest).

10. Community / circle operations design 〔few〕

For real-world communities I'm part of (language learning, hobby circles), I draft requirements documents, differentiation analyses, KPIs, and roadmaps; sometimes I run participant data analysis. A product-management sandbox.

What I'm watching / learning

Drawn from the ~734 starred repositories:

Recent top stars include claude-trading-skills, claude-skills (245+), anthropics/financial-services, microsoft/agent-framework, andrej-karpathy-skills, microsoft/autogen, stagehand, mangum (Lambda + ASGI) — the intersection of AI × finance × agents × infrastructure is my current focal point.

Working principles

• Ship the smallest thing that works. I touch the system before fully nailing the requirements.
• Go deep on tools I use weekly. TypeScript / Python / Ruby every week.
• Use personal projects as a testbed. New React versions, Next.js features, test runners, LLM APIs all start in personal repos before reaching production at work.
• Observe → Notify → Automate. Small automations to Slack / Discord / LINE in both work and life.
• Drive tickets to completion. I value the habit of finishing what was committed to.

Contact

Please reach out via the platform on which this resume was shared.