Improving systems
that others depend on.
I work on production platforms where architecture decisions compound over time.
My focus is on modernizing codebases, improving performance through measurable optimization,
and reducing engineering friction through better tooling and standards.
I connect technical work to product outcomes and business value.
Designing maintainable systems that remain easy to evolve. Favoring explicit contracts, clear boundaries, and patterns that reduce cognitive load.
Improving user and platform efficiency through measurable optimizations. Lighthouse scores, bundle analysis, and runtime profiling guide the work.
Reducing engineering friction through standards, tooling, and workflows. Linting, formatting, type safety, and CI/CD pipelines that catch issues early.
Connecting technical decisions to user needs and business outcomes. Every refactor or migration is justified by its impact on delivery and maintainability.
Context
XL SATU platform was running on Next.js Pages Router with growing technical debt. SEO-critical pages suffered from suboptimal rendering strategies, and the team was duplicating data-fetching logic across pages.
Problem
- Pages Router required manual SSR configuration per route
- Image delivery was unoptimized, impacting LCP scores
- No standardized tooling for code quality
Actions
- Migrated critical pages to App Router with React Server Components
- Implemented WebP image optimization pipeline with Next/Image
- Introduced ESLint, Prettier, Husky pre-commit hooks
- Built reusable component library with Zustand + React Query
Outcome
- Lighthouse scores improved by 40% on critical pages
- Reduced bundle size through RSC adoption
- Developer onboarding time decreased significantly
Impact
The migration established a foundation for the platform's next phase of growth. The team now ships features faster with confidence in code quality, and performance is a first-class consideration in every PR review.
Context
Aksesmu's mobile-first web app was built on Nuxt 2 with JavaScript and Options API. The codebase was becoming difficult to maintain as the product scaled, and type safety was nonexistent.
Problem
- Nuxt 2 approaching end-of-life with no upgrade path
- JavaScript codebase lacked type safety at API boundaries
- State management was inconsistent across modules
Actions
- Led full migration from Nuxt 2 to Nuxt 3
- Converted entire codebase from JavaScript to TypeScript
- Adopted Composition API for all components
- Introduced proxy API layer for type-safe backend communication
- Standardized state management with Pinia
Outcome
- Type safety across all API integrations
- Maintainability improved through consistent patterns
- Deployment flexibility with Nitro server engine
Impact
This migration future-proofed the product for 3+ years. The type-safe API layer caught integration bugs before they reached production, and the team could iterate on features without fear of breaking existing functionality.
Context
Wanake Studio needed a full-stack e-commerce solution with SEO-critical product pages, a non-technical admin CMS, and robust error monitoring for a production commerce environment.
Problem
- Product pages needed server-rendered structured data for Google Rich Results
- Admin interface had to be operable by non-technical staff
- Database read load was unsustainable without caching
Actions
- Built SSR storefront with Nuxt 3 + Nitro on Vercel
- Implemented Schema.org structured data (Product, BreadcrumbList)
- Designed PostgreSQL schema with row-level security on Supabase
- Built TTL-based Nitro route caching with cache invalidation
- Integrated Sentry for full-stack error monitoring
Outcome
- Google Rich Results eligibility for all product pages
- Reduced database read load through intelligent caching
- Full observability with client and server error tracking
Impact
The platform demonstrated that a single engineer can architect, build, and operate a production commerce system with proper tooling, caching strategies, and monitoring. The CMS is still operated by the client without engineering support.
Context
BRI's merchant-facing web app served real-time financial data to thousands of merchants. Page load speed and SEO were critical for user acquisition and retention in a competitive banking landscape.
Problem
- Client-side rendering caused poor initial load experience
- Real-time financial data required robust error handling
- Codebase was monolithic and hard to extend
Actions
- Implemented Server-Side Rendering for all critical pages
- Built dynamic API-driven components with edge-case handling
- Refactored monolith into reusable, scalable components
- Established component patterns used across the team
Outcome
- Significant improvement in page load speed and SEO
- Development velocity increased by ~25%
- Stable delivery in cross-functional Agile environment
Impact
This was my first enterprise-scale project. It taught me that refactoring is not just about cleaner code — it's about enabling the team to ship faster and with fewer bugs. The component patterns I established were adopted by the entire frontend team.
Investigating Core Web Vitals optimization patterns across Next.js App Router and Nuxt 3. Measuring real-world impact of RSC vs. SSR vs. CSR on e-commerce conversion.
Building internal CLI tools for scaffolding components, generating API types from OpenAPI specs, and automating repetitive frontend workflows.
Documenting system design patterns for full-stack applications: caching strategies, database schema design, and API architecture decisions.
Lessons from converting 30,000+ lines of JavaScript to TypeScript, adopting Composition API, and maintaining zero-downtime deployment during a framework migration.
The real tradeoffs of React Server Components in production: bundle size reduction, caching complexity, and the mental model shift for the team.
How a proxy API pattern with Zod validation and generated types improved our frontend-backend contract and caught integration bugs before production.
The difference between writing a style guide and building a toolchain that enforces it. How Husky, lint-staged, and CI gates changed our code review culture.
Let's talk about systems
I'm interested in conversations about architecture, performance, and how teams build software that lasts. Whether you're exploring a migration, improving developer experience, or designing a new platform — I'd like to hear about it.