Experience
- Plan-management API layer (15 endpoints): used the platform gateway as a BFF over internal gRPC services, with per-period aggregation across game types, state-machine guards, parallel calls (errgroup) and error-message masking. Swagger + mock first, so the frontend could integrate in parallel through three requirement changes. Merged to develop and deployed to the test environment.
- IM announcement system and group-operation logs (delivered to STG for testing, not released); investigated and fixed a performance regression caused by a teammate's push optimization (dev / STG stage, not released).
- Cross-service troubleshooting: after the test environment went up, I joined gateway, downstream-service and database logs by trace_id (Elasticsearch / Kibana), found why a success code was misjudged across services, and fixed it in a separate hotfix MR.
- AI-assisted development with Claude Code: most code was written by AI; I broke down requirements, made design decisions, reviewed and accepted the work. I set up Claude Code skills and parallel review sub-agents for MRs, releases and log investigation. I also improved a build script written by the ops team that rebuilds only the services changed in the git diff (12 OpenIM services; it used to rebuild everything). With on-demand Jenkins deploys, deploy time went from about 14–16 minutes to 2–3 minutes.
- Payments / top-up microservice, built from scratch: designed gRPC services for top-up orders, currencies, payment-channel settings and subscription activation with go-kratos (layered architecture + Wire DI), wired into cross-service flows such as member balance updates.
- Several third-party OAuth logins: Apple (multi-audience, Web + iOS) and social accounts (PKCE); designed a login toggle and an allowlist of routes that skip auth.
- API Gateway extension: a Go plugin for APISIX for site-wide config sync and IP allow/deny control (multi-tenant siteId).
- AI content generation and crawler: OpenAI-generated match-analysis articles (Chinese / Vietnamese); rebuilt the crawler core and added a backfill API with batch processing to ease DB load, plus expert assignment and duplicate-content conflict detection.
- GraphQL admin back office: permission menus, activity management and audit logs (schema / service work).
- Member-system maintenance and optimization; PHP crawlers, payment integration, blockchain applications (no smart contracts). Laravel · ThinkPHP · MySQL · Redis
Contract work
Go backend (Gin, GORM, MySQL, Redis), AI-assisted: Claude Code wrote the code under my direction; I handled requirement breakdown, design trade-offs, review and acceptance (including local and DEV e2e). The third-party payment protocol and the existing wallet logic were written by the client's own engineers.
- Extended and hardened top-up channel settings: added fields with backfill, batch ordering and delete protection; changed a unique index to a normal one so one code can have several merchants (after auditing every query that assumed uniqueness); order placement now uses the channel id and checks that the channel is enabled, not deleted and the code matches, which blocks orders on disabled channels.
- Back-office API to adjust member balances in batches: up to 1000 members per batch, one transaction per member, failures reported per item, with admin OTP confirmation and a separate permission.
- GitLab CI integration: tests, image build, updating the GitOps chart tag (verified on a rehearsal branch), and making DB migration a manual job in a shared module that runs after merge.
Rebuilt a legacy PHP (CodeIgniter 3) monolith on ThinkPHP 8. AI-assisted: Codex CLI and Claude Code wrote most of the code under my direction; I handled direction, breakdown, trade-offs and acceptance, and drove the work with guide files and OpenSpec specs. After the base architecture and the main module APIs were done, I handed the project over to the client to continue (I did not do the go-live, and there was no old-data migration).
- Rebuild plan and migration strategy: scanned the requests the old frontend actually sends, diffed them both ways against the full API list, and froze the API contracts the old frontend actually uses as the acceptance baseline. I chose rewrite-without-migration: the new version reads and writes the old database directly, with compatible routes so the old frontend needs no change.
- Four-layer architecture and JWT: ThinkPHP 8 with four layers; JWT with two tokens and automatic refresh on 401. Authentication is an application-level middleware with an allowlist.
- Event bus and plugin framework (dev environment only): designed an EventBus and a per-tenant plugin system (a restricted API, tenant authorization, auto-disable on high error rate). It was never demoed or used.
Personal projects
Designed and built from zero with AI assistance: it keeps Kafka behind a gateway and exposes only HTTP / SSE / WebSocket / MCP, so apps and AI agents can subscribe "in one line"; auth, rate limiting and multi-tenant isolation are handled by the platform. Live as a public beta with Free and Paid plans and third-party payment (Polar) subscriptions. A Go monorepo; SDKs are published on npm and PyPI, and the MCP server is listed in the official registry. I own architecture decisions, standards, review and the whole process; a large part of the implementation is produced by AI under my review.
- Payment subscriptions: checkout, webhook signature verification, a subscription state machine, and plan / quota linkage (a successful payment unlocks Paid quota; a failed charge gets a 7-day grace period, then Free limits apply without cutting off reads and writes). Hourly reconciliation catches missed events; state changes and notification emails share one transaction; alert rules are in place.
- Reliable delivery: webhook HMAC + retry + dead-letter queue (DLQ) + replay; metering is idempotent through offset high-water-mark dedup.
- Real-time + distributed state: SSE / WebSocket share a live-tail hub; cross-replica presence uses Redis ZSET heartbeats, with fail-open fallback to local.
- Quality through guardrails: TDD + integration tests + end-to-end smoke tests + contract-drift tests (actual routes ↔ OpenAPI, both ways) + a pre-merge code-review gate + monitoring alerts. A single-machine public beta, no SLA.
The ability to run the whole lifecycle myself, from environment setup to deployment and secure operation (important for remote work): Proxmox (PVE) isolated LXC dev environments with shared middleware (PostgreSQL / Redis / MongoDB); VPS services on Docker Compose with Nginx Proxy Manager as reverse proxy, automated Let's Encrypt TLS, and fail2ban / UFW hardening with a security review.