This portfolio features interactive elements and animations that require a desktop or tablet device.
Please visit on a larger screen to explore the full experience.
Full-stack developer and designer crafting immersive digital experiences. Specializing in interactive UI, scalable infrastructure, and performance-driven architecture.
Responsive Design / Interactive UI / Modern Frameworks
React, Tailwind, Three.js, and immersive web experiments.
View Projects βBuilding immersive web experiences with React, responsive layouts, and modern front-end frameworks.
Modern property listings with interactive search
AI-powered tech career platform with smart matching
Blockchain environmental donation platform
Design systems and user-centered workflows
API Development / AI Integration / Microservices
FastAPI, ONNX AI pipelines, and secure microservices.
Building scalable backends with FastAPI, AI pipelines, and secure microservices.
ONNX runtime with GPU acceleration
JWT authentication with Redis sessions
PostgreSQL with Redis caching
FastAPI routing & rate limiting
System Design / Performance / Scale
Distributed systems, performance optimization, and scalable infrastructure.
View Projects βDesigning distributed systems with performance optimization and scalable infrastructure.
Microservices with event-driven design
Caching strategies & query optimization
Sharding & replication patterns
Metrics, logging, and alerting
Turning complex problems into elegant solutions
With a Software Engineering degree from California State University and 8 years of hands-on experience, I've built my career spanning design, UI/UX, backend development, AI integration, and full-stack architecture. This multidisciplinary backgroundβfrom crafting intuitive user experiences to building scalable systemsβgives me a unique perspective on creating products that are both technically robust and beautifully crafted.
Whether designing intuitive interfaces, architecting scalable microservices, or optimizing system performance, I bring a holistic approach to every project. I believe great software lives at the intersection of engineering excellence and exceptional user experience.
Professional development solutions tailored to your needs
Interactive UIs, responsive design, and immersive 3D experiences with React, Next.js, and Three.js
Scalable APIs, database design, and server-side logic with Python, FastAPI, and Node.js
Cloud infrastructure, microservices, and performance-driven architecture design
End-to-end development from concept to deployment with ongoing support
Flexible engagement options available for project-based work and long-term contracts. Contact me to discuss your specific needs and timeline.
Have a project in mind? Get in touch and let's create something amazing.
San Francisco Bay Area, CA
Within 24 hours
Open to new projects
A modern real estate platform built for a premier firm specializing in luxury properties across California's Central Coast and Bay Area. The website features dynamic property listings, interactive search functionality, and a seamless user experience designed to showcase high-end real estate.
Custom video content and promotional materials created and edited using Adobe Creative Suite. Professional property showcases with cinematic editing, motion graphics, and brand-consistent visual storytelling to highlight luxury listings.
Built with React and integrated with real estate APIs for automatic property listing updates. Features include real-time availability, dynamic pricing, advanced filtering, and instant property search across multiple MLS databases.
Responsive, mobile-first design system built with Tailwind CSS. Features custom property cards, interactive image galleries, smooth animations, and a sophisticated color palette that reflects the luxury real estate market.
A comprehensive luxury real estate platform from concept to deployment
Client consultation, requirement gathering, and technical architecture design
Adobe XD wireframes, UI/UX design system, and interactive prototypes
React application build, API integration, and responsive component library
Quality assurance, performance optimization, and production deployment
Real-time property data for California's luxury market
Professional videography showcasing luxury estates
Adobe XD interface reflecting luxury brand identity
Multi-million dollar listing search and discovery
Created a premium digital showcase for H and H Real Estates that elevated their brand in California's luxury property market. The platform combined cinematic property videos, live MLS data integration, and sophisticated filtering to help clients sell multi-million dollar properties in the Bay Area and Central Coast. The custom video production and Adobe XD design system established H and H as the premier choice for luxury real estate in their market, resulting in increased property inquiries and faster time-to-sale for high-end listings.
An AI-powered tech career platform that connects job seekers with opportunities using intelligent matching algorithms. Features personalized job recommendations, skills assessment, AI-driven resume optimization, and real-time tech industry insights.
Advanced analytics providing deep insights into job market trends, salary ranges, required skills, and career progression paths. The platform analyzes thousands of job postings to give candidates data-driven career advice and help them make informed decisions.
Intelligent resume optimization that analyzes job descriptions and provides targeted suggestions. Extract key requirements, identify missing keywords, and enhance your resume with AI-driven recommendations to increase match scores and land more interviews.
Connect your GitHub account for comprehensive portfolio analysis. The platform evaluates your projects, languages, contributions, and coding patterns to provide insights and match you with opportunities that align with your technical expertise and development style.
Gain real-time insight into your market readiness, technical mastery, and earning potential powered by CareerNexus Intelligence. Track your engineering strength profile across critical skills like React, TypeScript, Python, AWS, and more with live market data and demand insights.
Seamless mobile experience designed for professionals on the go. Access your career dashboard, job recommendations, resume optimization, and portfolio analysis from any device with a fully responsive interface optimized for mobile job hunting.
A comprehensive AI-powered career platform revolutionizing tech recruitment
Market analysis, user research, and AI algorithm design
Machine learning model training and integration
React application with responsive UI components
User testing, performance optimization, and deployment
AI-driven optimization with real-time improvement suggestions
Automated analysis of developer projects and coding patterns
87% market readiness scores with personalized career insights
Real-time tech industry trends and targeted job matching
Revolutionized the tech career search experience with an AI-powered platform that analyzes GitHub portfolios, optimizes resumes, and delivers personalized job matching. The career quantification engine provides actionable insights with market readiness scores, helping developers and tech professionals advance their careers with data-driven intelligence and targeted recommendations.
A blockchain-powered environmental donation platform that revolutionizes giving through transparent tracking and cryptocurrency rewards. Eco Coin enables donors to make verified environmental contributions while earning tokenized incentives for eco-conscious behavior.
Browse and support verified environmental organizations with cryptocurrency donations. Each organization displays real-time impact metrics, verified status, and transparent fund allocation. Select from ocean conservation, reforestation, clean energy, and wildlife protection initiatives.
Real-time blockchain transaction monitoring and verification. Smart contracts ensure every donation is tracked immutably on the Ethereum blockchain, providing donors with complete transparency and instant confirmation of their environmental impact.
ECO COINS generate instant tax documentation via blockchain smart contracts. Each donation automatically creates verified tax receipts with immutable proof of contribution, simplifying tax filing for charitable giving.
Responsive Web3 wallet integration for seamless mobile donations. MetaMask and WalletConnect support enables users to donate and track their environmental impact on any device, anywhere, with secure blockchain authentication.
Multi-wallet support with MetaMask, WalletConnect, and Coinbase Wallet integration. Users can securely connect their crypto wallets, manage donations, and track their Eco Coin rewards through a unified, user-friendly interface with enterprise-grade security.
A comprehensive blockchain donation platform from concept to deployment
Blockchain architecture design and smart contract planning
Solidity contracts, token creation, and security audits
Web3 wallet connection and blockchain interaction UI
Smart contract testing, security verification, and mainnet deployment
Transparent blockchain tracking with immutable donation records
Cryptocurrency incentives for environmental contributions
Seamless MetaMask and WalletConnect support
Real-time environmental impact visualization and tracking
Created a groundbreaking blockchain platform that brings transparency and innovation to environmental giving. Through smart contracts and tokenized rewards, Eco Coin enables donors to track their environmental impact in real-time while earning cryptocurrency incentives. The Web3 integration and immutable donation records establish trust and accountability, revolutionizing how organizations and individuals contribute to environmental causes.
Scalable backend infrastructure built on modern microservices patterns. Features API Gateway routing, independent service scaling, Redis caching layer, and PostgreSQL database clusters. Designed for high availability with Docker containerization and Kubernetes orchestration.
# Enterprise JWT Authentication with Redis Session Store
from fastapi import FastAPI, HTTPException, Depends, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from passlib.context import CryptContext
from datetime import datetime, timedelta
from typing import Optional
import jwt
import redis.asyncio as redis
app = FastAPI(title="Auth Service")
# Security configuration
SECRET_KEY = "your-secret-key-here"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 60
# bcrypt context for password hashing (cost factor 12)
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto", bcrypt__rounds=12)
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
# Redis connection for session storage
redis_client = await redis.Redis(
host="redis",
port=6379,
db=0,
decode_responses=True
)
def verify_password(plain_password: str, hashed_password: str) -> bool:
return pwd_context.verify(plain_password, hashed_password)
def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
to_encode = data.copy()
expire = datetime.utcnow() + (expires_delta or timedelta(minutes=15))
to_encode.update({"exp": expire})
encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
return encoded_jwt
@app.post("/api/v1/auth/login")
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
# Authenticate user from database
user = await db.get_user_by_email(form_data.username)
if not user or not verify_password(form_data.password, user.password_hash):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Incorrect email or password",
headers={"WWW-Authenticate": "Bearer"}
)
# Create JWT token
access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
access_token = create_access_token(
data={"sub": user.id, "email": user.email, "role": user.role},
expires_delta=access_token_expires
)
# Cache session in Redis with 1 hour TTL
await redis_client.setex(
f"session:{user.id}",
3600,
access_token
)
return {
"access_token": access_token,
"token_type": "bearer",
"expires_in": 3600
}Production-grade JWT authentication system with Redis session management. Features bcrypt password hashing (cost 12), automatic token refresh, rate limiting (5 req/min), and instant session invalidation. Handles 10,000+ daily authentications with sub-100ms response times and 99.9% uptime SLA.
Production-ready model deployment with ONNX Runtime, CUDA acceleration, and sub-50ms inference times.
POST /api/v1/predict
multipart/form-dataResize & Normalize
640Γ640 β’ HWCβCHWGPU Execution
CUDA 11.8 β’ 42msNMS & Format
conf: 0.5 β’ IoU: 0.45Optimized PostgreSQL schema with UUID primary keys, indexed foreign keys, and automatic timestamp tracking. Implements partitioning for API logs, master-slave async replication, and SQLAlchemy ORM connection pooling.
# ONNX Runtime AI Inference Pipeline with GPU Acceleration
from fastapi import FastAPI, File, UploadFile
from typing import List, Dict
import onnxruntime as ort
import numpy as np
import cv2
import time
app = FastAPI(title="AI Inference Service")
# Initialize ONNX Runtime with CUDA providers
session = ort.InferenceSession(
"models/yolov8n.onnx",
providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
)
@app.post("/api/v1/predict")
async def predict_image(file: UploadFile = File(...)):
start_time = time.perf_counter()
# Image upload and decode
contents = await file.read()
nparr = np.frombuffer(contents, np.uint8)
image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
# Preprocess: resize, normalize, transpose
img = cv2.resize(image, (640, 640))
img = img.transpose(2, 0, 1) # HWC β CHW
img = np.expand_dims(img, axis=0)
input_tensor = img.astype(np.float32) / 255.0
# Run GPU inference
outputs = session.run(
None,
{"images": input_tensor}
)
# Postprocess: NMS and confidence filtering
detections = postprocess(
outputs[0],
conf_threshold=0.5,
iou_threshold=0.45
)
inference_time = (time.perf_counter() - start_time) * 1000
return {
"status": "success",
"detections": len(detections),
"inference_ms": round(inference_time, 2),
"provider": session.get_providers()[0]
}# ONNX Runtime AI Inference Pipeline with GPU Acceleration
import onnxruntime as ort
from fastapi import FastAPI, File, UploadFile, HTTPException
from typing import List, Dict
import numpy as np
import cv2
import time
app = FastAPI(title="AI Inference Service")
# Initialize ONNX Runtime with GPU providers
session = ort.InferenceSession(
"models/yolov8n.onnx",
providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
)
async def preprocess(image: np.ndarray) -> np.ndarray:
"""Resize to 640x640 and normalize for YOLO"""
img = cv2.resize(image, (640, 640))
img = img.transpose(2, 0, 1) # HWC to CHW
img = np.expand_dims(img, axis=0).astype(np.float32) / 255.0
return img
@app.post("/api/v1/predict")
async def predict_image(file: UploadFile = File(...)):
start_time = time.perf_counter()
# Read and decode image
contents = await file.read()
nparr = np.frombuffer(contents, np.uint8)
image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
# Preprocess for model
input_tensor = await preprocess(image)
# Run inference on GPU
outputs = session.run(None, {"images": input_tensor})
# Postprocess detections
detections = postprocess(outputs[0], conf_threshold=0.5, iou_threshold=0.45)
inference_time = (time.perf_counter() - start_time) * 1000
return {
"status": "success",
"detections": len(detections),
"objects": detections,
"inference_ms": round(inference_time, 2),
"model": "yolov8n",
"provider": session.get_providers()[0]
}Production ML inference using ONNX Runtime with GPU acceleration (CUDA 11.8). Supports YOLOv8 object detection, model versioning for A/B testing, batch processing (32 images/sec), and automatic model warm-up. Achieves 42ms inference time with 94% accuracy, handling 100K+ daily predictions.
Optimized for high-throughput scenarios with async request handling and connection pooling. Load-tested to handle 10,000+ concurrent requests with sub-50ms response times. Implements circuit breakers, graceful degradation, and automatic scaling based on CPU/memory metrics.
# Data Service with Redis Caching & PostgreSQL
from fastapi import FastAPI, Depends
from sqlalchemy.ext.asyncio import AsyncSession
import redis.asyncio as redis, json
redis_client = redis.Redis(host="redis", decode_responses=True)
async def get_user_data(user_id: str, db: AsyncSession):
cache_key = f"user:{user_id}"
# Try cache first (sub-1ms latency)
cached = await redis_client.get(cache_key)
if cached:
return json.loads(cached)
# Query PostgreSQL with async
result = await db.execute(
select(User).where(User.id == user_id)
)
user = result.scalar_one_or_none()
# Cache for 5 minutes
await redis_client.setex(
cache_key,
300,
json.dumps(user.dict())
)
return user
# Batch operations for efficiency
async def bulk_insert(records: List[Dict]):
await db.execute(insert(Table).values(records))
await db.commit()High-performance data layer with Redis caching (< 1ms reads, 95% hit rate) and PostgreSQL backend. Features connection pooling (max 100), async query execution (< 5ms), bulk operations (1K rows/sec), and query optimization with indexing. Handles 50K+ queries per second with automatic cache invalidation.
{
"detections": 3,
"objects": [
{"class": "person", "conf": 0.94},
{"class": "car", "conf": 0.87},
{"class": "dog", "conf": 0.91}
],
"inference_time_ms": 42
}
Production ML inference pipeline using ONNX Runtime for cross-platform compatibility. Features GPU acceleration, model versioning, A/B testing capabilities, and real-time prediction endpoints. Optimized for computer vision tasks with batch processing support and automatic model warm-up.
# PostgreSQL Cluster with Master-Slave Replication
from sqlalchemy import create_engine
from sqlalchemy.pool import QueuePool
# Master node for writes
master_engine = create_engine(
"postgresql+asyncpg://user@master:5432/db",
poolclass=QueuePool,
pool_size=50,
max_overflow=100,
pool_timeout=30
)
# Read replicas for load distribution
slave_engines = [
create_engine("postgresql+asyncpg://user@slave1:5432/db"),
create_engine("postgresql+asyncpg://user@slave2:5432/db")
]
def get_read_engine():
# Round-robin load balancing
return random.choice(slave_engines)
# Table partitioning for high-volume data
CREATE TABLE api_logs (
id BIGSERIAL,
endpoint VARCHAR(255),
created_at TIMESTAMP
) PARTITION BY RANGE (created_at);
# Monthly partitions for efficient queries
CREATE TABLE api_logs_2025_01
PARTITION OF api_logs
FOR VALUES FROM ('2025-01-01') TO ('2025-02-01');Highly available PostgreSQL cluster with master-slave async replication and round-robin load balancing. Features connection pooling (50 base, 100 overflow), table partitioning by month, and hourly automated backups. Stores 50TB+ data, handles 100K concurrent connections with < 10ms query latency.
# Redis Media Cache with LRU Eviction
import redis.asyncio as redis
from typing import Optional
redis_client = redis.Redis(
host="redis-cluster",
port=6379,
db=0,
decode_responses=True,
max_connections=1000
)
async def cache_media(key: str, data: bytes, ttl: int = 3600):
# Store media with auto-expiry
await redis_client.setex(key, ttl, data)
async def get_cached_media(key: str) -> Optional[bytes]:
# Sub-millisecond retrieval
return await redis_client.get(key)
# Cache invalidation patterns
async def invalidate_pattern(pattern: str):
keys = await redis_client.keys(pattern)
if keys:
await redis_client.delete(*keys)
# PubSub for real-time cache updates
pubsub = redis_client.pubsub()
await pubsub.subscribe("cache:invalidate")
# Redis configuration for max memory
# maxmemory 10gb
# maxmemory-policy allkeys-lruHigh-performance Redis caching layer with LRU eviction policy and 10GB max memory. Features sub-millisecond retrieval (< 1ms), pattern-based bulk operations, PubSub for real-time cache invalidation, and 1000 max connections. Achieves 98% hit rate handling 500K+ operations per second.
# FastAPI Gateway with Middleware
from fastapi import FastAPI, Request, HTTPException
from slowapi import Limiter
import httpx
app = FastAPI()
limiter = Limiter(key_func=lambda request: request.client.host)
# Service registry for routing
services = {
"auth": "http://auth-service:8001",
"ai": "http://ai-service:8002",
"data": "http://data-service:8003"
}
@app.middleware("http")
async def route_middleware(request: Request, call_next):
# Extract service from path
service = request.url.path.split("/")[2]
# Forward to microservice
async with httpx.AsyncClient() as client:
response = await client.request(
method=request.method,
url=f"{services[service]}{request.url.path}",
headers=request.headers,
content=await request.body()
)
return response
@limiter.limit("1000/minute")
@app.get("/api/v1/{service}/{path:path}")
async def gateway(service: str, path: str):
# Auto-routes with rate limiting
passCentralized FastAPI gateway handling routing, rate limiting (1000 req/min), JWT authentication, and load balancing. Features service discovery, request/response logging, CORS policies, and automatic failover. Routes 25K+ requests per second with < 5ms latency and 99.99% availability.
PostgreSQL database with optimized schema design featuring UUID primary keys, indexed foreign keys, and automatic timestamp tracking. Implements table partitioning for high-volume log data, master-slave replication for read scalability, and connection pooling with SQLAlchemy ORM.