I build software the way it's built in production.
Enterprise-ready portfolio
Fork this repository to jump-start a production-ready web and mobile platform. Built with enterprise architecture principles, shared contracts, and real deployment workflows.
About Portfolio Website
Shared Contracts
Zod schemas keep APIs and UI aligned across web and mobile.
Edge-ready Delivery
Server components, CDN caching, and serverless APIs by default.
Scalable Collaboration
Monorepo boundaries make ownership and reviews predictable.
This website is intentionally designed as more than a static portfolio - it is a production-grade foundation that mirrors how modern, scalable products are built in real-world engineering organizations. It is implemented as a monorepo with a clear separation of concerns, enabling multiple applications (web and mobile) to evolve from a single, cohesive codebase. The web experience is built using Next.js with the App Router, leveraging server components by default for performance, SEO, and security, while selectively opting into client components only where interactivity is required. This ensures minimal client-side JavaScript, faster load times, and a clean mental model of what runs on the server versus the browser.
Key architectural considerations include:
- Shared contracts and validation: Business logic, input validation, and API contracts are centralized using shared schemas, ensuring consistency across web and mobile clients and preventing frontend/backend drift.
- Scalable deployment model: The web application is deployed on a global edge platform with automatic HTTPS, CDN caching, and serverless APIs, reflecting how modern teams ship reliable software at scale.
- Mobile-first extensibility: A parallel mobile application is built using a file-based router that mirrors the web routing model, enabling feature parity and long-term reuse without architectural rewrites.
- Enterprise-friendly structure: The repository is structured to naturally support future additions such as authentication, dashboards, role-based access control, databases, and shared UI libraries - without refactoring core foundations.
- Maintainability and collaboration: Clear boundaries between apps, shared packages, and infrastructure make the codebase easy to reason about, review, and extend - optimizing for team velocity, not just individual productivity.
In short, this website demonstrates deliberate engineering choices focused on scalability, correctness, performance, and long-term evolution. It reflects how I think about building software: starting with a strong architectural backbone, minimizing technical debt early, and designing systems that can grow from a personal project into an enterprise-ready product with confidence.
Monorepo + shared contracts
A single source of truth for product foundations without coupling teams.
- Apps and packages separated by domain boundaries for clean ownership.
- Shared schemas keep API contracts consistent across web and mobile.
- Centralized UI primitives enforce design and interaction consistency.
GitHub README
Open README# Enterprise-Ready Portfolio
### Production-grade web & mobile architecture -> designed to be forked, extended, and shipped
> **Designing and shipping production-grade web and mobile systems.**
This repository is intentionally **not a static portfolio** or a visual demo.
It is a **real, production-ready foundation** that demonstrates how modern engineering teams design, validate, deploy, and evolve software systems over time.
If you are a developer forking this repository, you are starting from a **clean, scalable baseline** - not just a demo.
If you are a hiring manager, engineering manager, or senior engineer reviewing this repository, you are looking at the **same architectural patterns** I use when building real products.
---
## About this website
This website was built with a single guiding principle:
> **Treat even small projects like production systems.**
Rather than optimizing for speed of setup or visual flash, this portfolio prioritizes:
- clear architectural boundaries
- shared contracts instead of duplicated logic
- server-first rendering and correctness
- realistic deployment workflows
- long-term extensibility
The result is a portfolio that can naturally evolve into:
- a SaaS product
- a B2B dashboard
- a mobile-first application
- or a multi-client production platform
...without rewriting the foundations.
---
## Why this portfolio is different
Most portfolios optimize for **appearance**.
This one optimizes for **engineering judgment**.
What you'll notice here:
- Architecture before UI (I still made it pretty though ;))
- Shared contracts across clients
- Web and mobile parity
- Real deployment pipeline
- Forkable by design
---
## Repository structure (Monorepo)
```txt
enterprise-portfolio/
- apps/
- web/
- mobile/
- packages/
- shared/
- README.md
```
---
## Component-level architecture
```txt
Web Client -->
Shared Domain (@repo/shared)
Mobile App -->
Next.js API Routes
Vercel Serverless
```
---
## Frameworks and interaction
### Next.js
- Server Components
- App Router
- API Routes
### Expo
- Native mobile app
- File-based routing
- Same API contracts
### Zod
- Shared validation
- Runtime safety
---
## Local development
```bash
corepack enable
corepack prepare pnpm@latest --activate
pnpm install
pnpm --filter web dev
pnpm --filter mobile start
```
---
## Deploy to Vercel
- Root Directory: apps/web
- Install Command:
```bash
cd ../.. && pnpm install
```
- Build Command:
```bash
cd ../.. && pnpm --filter web build
```
---
## For Custom domain (Recommended to refer vercel documentation to avoid outdated server information)
```txt
A @ 76.76.21.21
CNAME www cname.vercel-dns.com
```
---
## Fork this repo
Fork this repository to jump-start a production-ready platform.
---
## Final note
Built with scalability, correctness, and real-world production in mind.