I'm a Full-Stack Web Developer with 4+ years of experience, specializing in modern frontend development and increasingly focusing on software architecture, extensible UI systems, and product engineering.

My primary stack revolves around:

• Frontend: React, Next.js, TypeScript
• Backend: Node.js, NestJS
• Data: PostgreSQL, Prisma, Redis
• Infrastructure: AWS, S3-compatible storage, Docker, Nginx, Linux
• Architecture: Runtime UI, SDUI-inspired systems, component registries, modular frontend architecture

I enjoy working on problems where the answer is not simply:

"Build another page."

but rather:

"How should this system evolve when there are 5 templates today, 100 tomorrow, multiple products, changing schemas, non-developer users, and production constraints?"

A portfolio and career workflow platform that has gradually evolved from a conventional web application into an exploration of runtime-driven UI architecture.

User Data
   ↓
Structured Schema
   ↓
Template / Section Configuration
   ↓
Component Registry
   ↓
Runtime Renderer
   ↓
Published Portfolio

Some of the engineering problems I work on include:

• Template-driven portfolio publishing
• Runtime UI and SDUI-inspired rendering
• Dynamic section and component composition
• Frontend/backend schema contracts
• Component registry design
• Template versioning and extensibility
• Public portfolio routing and custom slugs
• Authentication and refresh-token flows
• Multilingual content and UI
• PostgreSQL data modeling with Prisma
• Redis-backed infrastructure
• S3-compatible asset storage
• Runtime configuration validation and rollback strategies

Core stack

Next.js
React
TypeScript
Tailwind CSS

NestJS
PostgreSQL
Prisma
Redis

S3-compatible Storage
AWS / Linux / Nginx

One principle behind the project:

AI should accelerate an architecture — not replace the need to design one.

I started Portflow by building the system manually, stabilizing its core patterns and constraints first. AI-assisted development is now used as leverage for template generation, repetitive implementation, exploration, refactoring, and engineering workflows.

Frontend Architecture
├── React / Next.js
├── Runtime UI
├── SDUI-inspired rendering
├── Component registries
├── Design systems
├── Microfrontend architecture
└── Performance & build optimization

Backend & Data
├── Node.js / NestJS
├── PostgreSQL
├── Prisma
├── Redis
├── Authentication
├── Queues & asynchronous workflows
└── API contract design

Infrastructure
├── AWS
├── S3-compatible storage
├── Docker
├── Nginx
├── Linux
└── Deployment architecture

Exploration
├── AI-assisted engineering
├── Interactive web experiences
├── 2D isometric interfaces
├── High-performance asset delivery
└── Scalable realtime systems

I do not believe every project needs microservices, SDUI, event-driven architecture, or five databases from day one.

But I do believe architecture should make future constraints visible before they become emergencies.

Monolith          before Microservices
Static UI         before Runtime UI
Direct calls      before Queues
PostgreSQL        before adding more databases
Simple deployment before orchestration

Until the complexity is justified.

Not everything needs to be generic.

The goal is not maximum abstraction.

The goal is to identify the parts of a product that will change repeatedly — and design strong boundaries around them.