Available for engineering opportunities• Frontend depth | Full-stack perspective

Software that lasts.
Built with performance, simplicity & long-term thinking.

I build web products across frontend, backend, cloud and AI, engineering the states, boundaries and details that make software feel clear, fast and dependable.

Explore selected work Get in touch Résumé

Product Focus

Software is experienced through its states, response times, edge-case handling and interface clarity, not isolated code fragments.

Engineering Depth

Frontend depth across React, Next.js and the TanStack ecosystem, paired with typed NestJS services, PostgreSQL persistence and CASL authorization.

Verifiable Evidence

Supported by inspectable public repositories, 77 automated test specification files, graph algorithms and multi-tenant authorization models.

02 / Selected Engineering Work

Case studies & inspectable decisions.

Selected frontend, backend and full-stack systems, presented through architecture, state boundaries and verifiable implementation evidence.

FrontendApril 2328, 2026

Cinedash

A high-performance film-discovery interface delivered within a seven-day constraint.

A film-discovery frontend combining typed URL state, infinite queries, virtualized rendering, persistent user state, explicit interface states, automated tests, CI, and Cloudflare Pages deployment.

Engineering Focus:

Assigning each form of state to a mechanism matching its lifecycle
Representing search and filters as navigable URL product state
Keeping rendering work proportional to the viewport as collections expand through virtualization

React 19
Vite
Strict TypeScript
TanStack Query
TanStack Router
TanStack Table
TanStack Virtual
Zustand Persistence
React Hook Form
Zod
Tailwind CSS
Vitest & RTL
MSW
Cloudflare Pages

77 Test Specification FilesInspect case study

FrontendSeptember 25, 2025

CaseFlow

Interactive investigation canvas & state model

An interactive investigation system coordinating heterogeneous clues, spatial organization, graph relationships, editing, history, and JSON export through React Flow state controlled by application-level model hooks.

Engineering Focus:

The board as both graph structure and spatial document
Stable identity preservation while clues move or change container context
Explicit content variants (text, image, audio, video) using discriminated unions

React Flow Canvas
MVVM-Inspired Structure
Strict TypeScript
Zod Discriminated Unions
Custom Snapshot History
Memoized Viewport Rendering
React Flow JSON Export

Inspectable ArchitectureInspect case study

BackendOctober 26, 2024

Top One

Commercial backend with domain modeling & contextual authorization

A commercial backend where domain modeling, application use cases, persistence boundaries, contextual authorization, and automated regression protection make business responsibility visible in the code.

Engineering Focus:

Data becomes more consequential as it transitions into a commercial commitment
Authentication identifies the actor; the resource context determines allowed capabilities
Authorization conditions built strictly from authoritative stored database values

NestJS
Prisma ORM
PostgreSQL
CASL Authorization
Either-style Result Types
Domain Events
HTTP & Integration Tests

Inspectable ArchitectureInspect case study

Full-stackSeptember 26, 2024

Next SaaS RBAC

Multi-tenant full-stack identity, organization & permission architecture

A multi-tenant full-stack application where authentication, organizations, memberships, role abilities, resource ownership, invitations, projects, billing, and ownership transfer are coordinated across a shared web and API architecture.

Engineering Focus:

Authentication, tenancy, and authorization are distinct, non-interchangeable contexts
Roles belong to memberships within organizations, not globally to an isolated user
A resource can belong simultaneously to a tenant organization and an individual owner

Turborepo Workspaces
Next.js App Router
Fastify REST API
Prisma ORM
Zod & OpenAPI
Shared CASL Package
Server Actions

Inspectable ArchitectureInspect case study

Confidential Professional Work

Anonymized Engineering Case Study

Content & Operations Platform

Responsibility: Primary Developer & System Architect

“An editor publishes a change. The system coordinates identity, data, media, and public delivery.”

End-to-end architecture and implementation of a production Nx monorepo spanning a React administrative application, a NestJS/Fastify API, a Next.js public site, and shared authorization and UI libraries.

Core Architectural Challenge:

Keeping administrative operations, relational state, object storage, and public cache behavior consistent across independently deployed applications. Mandatory first-login 2FA, server-authoritative CASL rules, direct R2 uploads, and tag-based revalidation must converge without exposing the organization or coupling the public experience to the administrative runtime.

Publishing & Security Invariants

01.Sessions are issued only after password and mandatory TOTP verification; challenges are short-lived and single-use
02.The API remains authoritative for permissions, persistence, and published content state
03.Successful mutations revalidate only affected public cache tags after authoritative persistence

Nx MonorepoNestJS / FastifyReact / Next.jsPrisma / MariaDBCloudflare R2CASL & TOTP

Confidential Professional Work

Anonymized Engineering Case Study

Visual No-Code Workflow System

Responsibility: React Flow Architecture & Graph Consistency

“The user moves a line. The system preserves a program.”

Architecture and implementation work on a complex visual workflow canvas where users create, connect, configure, move, delete and copy workflow nodes.

Core Architectural Challenge:

Preserving graph consistency when visible UI actions affect stored reference structures. Node execution dependencies require edge updates, deletion, and copy-paste operations to reconstruct unique identities and relationships safely without leaving orphaned state.

Graph Consistency Invariants

01.Edge movement automatically updates parent/child dependency arrays
02.Copy-and-paste safely reconstructs node IDs and internal graph relationships
03.Deletion cascades clean up dangling references before state persistence

React FlowTypeScriptGraph State TransformationsReference Synchronization

02.1 / System & State Architecture

Inspectable execution paths.

Select a project to trace how interactions, state transitions, authorization boundaries and persistence decisions coordinate in practice.

Execution Sequence (4 Steps)

Cinedash / Architecture Trace

Step 1 of 4

1. Navigation & URL State (TanStack Router)

The user selects the 'Sci-Fi' genre and a rating filter. The filter state is written directly to URL query parameters (`/movies?genre=sci-fi&rating=8.0`).

Implementation pattern:

const search = useSearch({ from: '/movies/' });
// Navigable & shareable URL product state

03 / ENGINEERING PHILOSOPHY

How software should be built.

A software system is judged by its behavior at the boundaries. Principles made concrete through practical engineering decisions.01 / 05

01USER EXPERIENCE• 1. EVALUATION THROUGH EXPERIENCE

Users experience software, not source code.

The quality of an implementation becomes visible through responsiveness, clarity, feedback and reliability across every viewport.

Core Requirements:RESPONSIVENESSCLARITYFEEDBACKRELIABILITY

03.1 / INTERACTIVE STATE ARCHITECTURE

Every state belongs to the feature.

Explore how interface feedback and system behavior change across loading, success, empty, error, denied and recovery conditions.

FEATURE LIFECYCLE INSPECTOR

A complete feature includes more than its populated state.

Explore how interface feedback and system behavior change across a complete feature lifecycle.

Loading state

Intent-based prefetching & skeleton fallbacks

User Experience Feedback:

Skeleton content preserves the expected layout while remote data is still resolving.

System Behavior:

Cached data and intent-based prefetch reduce repeated waiting without hiding the pending state.

app/movies/collection?page=1&filter=sci-fi

REQUEST PENDING

State remains explicitInspect behavior

04 / Professional History

Growing responsibility across web systems.

A career spanning reliable product interfaces, server architecture, persistence boundaries and codebases designed to remain maintainable.

01 • November 2024 — Present

Software Engineer@ Concentrix

React
TypeScript
TanStack Router / Query / Virtual
Material UI
Next.js

Core Engineering Scope:

Builds end-to-end web systems spanning React and Next.js frontends, NestJS/Node.js services, PostgreSQL/TypeORM persistence, and Dockerized environments.
Uses TanStack Router for typed navigation, TanStack Query for server-state synchronization, and TanStack Virtual for efficiently rendering data-heavy interfaces.
Develops interfaces with TypeScript, Material UI, and Tailwind CSS, with attention to accessibility, responsive behavior, and interaction clarity.
Works with application workloads and asynchronous flows supported by Google Cloud services, including Cloud Run, Cloud Scheduler, and Pub/Sub.
Supports software quality with Vitest, Testing Library, Supertest, Storybook, and participation across architecture, delivery, and ongoing maintenance.

02 • May 2023 — September 2024

Frontend Developer@ Ignis

React
Next.js
TypeScript
Tailwind CSS
styled-components / Chakra UI

Core Engineering Scope:

Developed and maintained responsive web interfaces with React, Next.js, TypeScript, Tailwind CSS, styled-components, and Chakra UI.
Created unit and integration tests with Jest and Testing Library, and documented reusable components in Storybook.
Integrated frontend applications with REST APIs while refining loading performance, responsive and mobile-first behavior, and interaction reliability.
Collaborated with cross-functional teams through agile delivery, code reviews, and iterative interface refinement.
Applied frontend security practices focused on protecting user data and reducing exposure to common client-side vulnerabilities.

03 • February 2022 — September 2022

Full Stack Developer@ Tera

JavaScript / TypeScript
React
Node.js
REST APIs
Relational Databases

Core Engineering Scope:

Established foundational full-stack capabilities building user interfaces, backend services, and database queries.
Implemented core product features connecting client interactions directly with server-side validation and persistence.

05 / Capabilities & Stack

Organized around engineering responsibilities.

Technologies serve explicit product outcomes. Capability areas grounded in inspectable implementations.

01Verified

Product Interfaces & Frontend

Building responsive, highly reliable interactive interfaces where state lifecycles match user intent.

React & Next.js App Router
Strict TypeScript Architecture
TanStack Suite (Query, Router, Table, Virtual)
React Hook Form & Zod Validation
State Management (Zustand, Context)
Tailwind CSS & Editorial Systems
React Flow Spatial Canvases
Complete Interface States (Loading/Success/Empty/Error/Denied/Recovery)
Performance & Accessibility Optimization

02Verified

Backend Systems & APIs

Designing structured backend services with explicit domain use cases, mappers, and authoritative authorization.

Node.js & NestJS
Type-safe REST API Architecture
Contextual Authorization (CASL)
Domain Modeling & Application Use Cases
Repository Contracts & Mappers
Either-style Result Error Handling
Authentication & JWT / Session Flows
Automated HTTP Integration Testing

03Verified

Data & Persistence

Structuring relational databases and ORM mappers to enforce business invariants at query level.

PostgreSQL & MySQL Databases
Prisma ORM & TypeORM Mappers
Redis Caching Strategies
Tenant-Scoped Queries
Relational Schema Design
Transactional Persistence Boundaries

04Verified

Cloud & Delivery

Containerizing applications and establishing reliable deployment pipelines for continuous delivery.

AWS Services
Docker Containerization
Cloudflare Pages & Edge Hosting
CI/CD Pipeline Automation
Environment Configuration & Secrets

05Verified

Artificial Intelligence Integration

Incorporating AI capabilities into products to support user judgment and streamline workflows.

OpenAI & LLM API Integration
Realtime API & Audio Streaming
RAG (Retrieval-Augmented Generation)
Prompt Engineering & Context Design
Verification-Conscious Output Handling

06 / Technical Writing & Architecture

Making complex decisions understandable.

Writing that clarifies software trade-offs, form architecture and module boundaries for engineering teams.

Frontend Architecture & ValidationVerified Overview

Multi-Schema Form Architecture with React Hook Form and Zod

How to structure complex multi-step and conditional forms using discriminated Zod unions, isolating form state while preserving full type inference across step boundaries.

Core Architectural Insights:

Discriminated unions ensure runtime validation matches step conditions
Type inference eliminates manual form interface duplication
Decoupling form layout from validation schema improves reusability

Code Organization & MaintainabilityVerified Overview

Module-Based Frontend Organization for Scaling Codebases

Moving beyond generic /components directories toward feature-owned module boundaries that encapsulate state, UI, API contracts, and tests in predictable structures.

Core Architectural Insights:

Feature-scoped folders reduce cross-file navigation friction
Public API exports (`index.ts`) help preserve module boundaries
Simplifies refactoring and isolated component testing using Storybook and Vitest