import type { Developer } from '@types/world';

const sahil: Developer = {
  name:     "Sahil Ijaz",
  role:     "Full Stack Developer",
  location: "Lahore, Pakistan 🇵🇰",
  contact:  "hssahil2913@gmail.com",

  // career arc — backend-first, then full stack
  journey: [
    { year: "2023",             phase: "Self-taught — C++, HTML/CSS, JS, Node.js" },
    { year: "Jan 2024–Sep 2025", phase: "Backend Developer — APIs, auth, DBs, real-time" },
    { year: "Oct 2025–present",  phase: "Full Stack Dev — UI → API → DB → cloud" },
  ],

  stack: {
    frontend:  ["Next.js", "React", "TypeScript", "TailwindCSS", "React Query"],
    backend:   ["Node.js", "Express.js", "NestJS", "Socket.io", "Zod"],
    database:  ["MongoDB", "PostgreSQL", "Prisma", "Mongoose", "Supabase"],
    cloud:     ["AWS (EC2, S3, Lambda)", "Vercel", "Firebase", "Nginx"],
    tools:     ["Git", "Postman", "JWT", "Swagger/OpenAPI", "pnpm", "Docker"],
  },

  available: true,
  hire:      () => "hssahil2913@gmail.com",
};

export default sahil;

I build fast, scalable, user-centric web applications from end to end. Backend-first mindset — I design the API and data model before touching the UI. I own the full lifecycle: architecture, code, tests, deployment, and iteration. Based in Lahore, Pakistan. Open to remote roles globally.

┌─── Client Layer ──────────────────────────────────────────┐
│  Next.js App Router  ·  React  ·  TailwindCSS             │
│  TypeScript  ·  React Query  ·  Zod (client validation)   │
└───────────────────────┬───────────────────────────────────┘
                        │  HTTPS / REST / WebSocket
┌───────────────────────▼───────────────────────────────────┐
│  Node.js / Express.js / NestJS                            │
│  JWT Auth  ·  RBAC  ·  Rate Limiting  ·  Zod Validation  │
│  Swagger/OpenAPI Docs  ·  Structured Error Handling       │
└──────────┬───────────────────────────────┬────────────────┘
           │                               │
┌──────────▼──────────────┐   ┌────────────▼──────────────┐
│  MongoDB / Mongoose     │   │  PostgreSQL / Prisma ORM  │
│  Document store         │   │  Relational data + joins  │
│  Aggregation pipelines  │   │  Migrations & type safety │
└──────────┬──────────────┘   └────────────┬──────────────┘
           └───────────────┬───────────────┘
┌──────────────────────────▼───────────────────────────────┐
│  AWS (EC2 · S3 · Lambda · CloudFront)                    │
│  Vercel  ·  Firebase  ·  Nginx  ·  Redis Cache           │
└───────────────────────────────────────────────────────────┘

$ git log --oneline --graph --all

* a9f3d21 (HEAD → main, origin/main) feat: real-time notifications via Socket.io
* c82e14b refactor: migrate auth middleware to NestJS guards
* f1d7c93 fix: resolve N+1 query issue in product aggregation
* 3b8a047 (tag: v2.1.0) feat: Stripe webhook handler with idempotency keys
* 71e2c85 chore: Prisma migrations for multi-tenant schema
* 90d4f31 perf: Redis caching layer — API latency reduced 40%
* 2a9c18e docs: complete OpenAPI/Swagger spec for all endpoints
* b7d183c test: add integration tests for JWT auth flow (92% coverage)
* 4e9c271 feat: implement fine-grained RBAC with permission scopes
* 17fa832 (tag: v2.0.0) feat: migrate to Next.js App Router (SSR + RSC)
* 9c3e554 feat: add Prisma ORM — replace raw SQL with type-safe queries
* e40a182 fix: socket room memory leak on client disconnect
* 3d91bc7 feat: multi-file S3 upload with pre-signed URLs + progress

Industry · Current role · Full-time

Stepped into full-stack ownership after mastering backend engineering. Now delivers complete features end-to-end — polished Next.js frontends, robust Node.js APIs, database architecture, and AWS cloud deployments. Owns every layer of the stack independently from spec to production.

What I do day-to-day:

• Build and ship Next.js App Router applications (SSR, SSG, ISR, React Server Components)
• Design clean REST APIs with full Swagger/OpenAPI documentation
• Architect MongoDB schemas and PostgreSQL data models for production scale
• Deploy and manage applications on AWS (EC2, S3, Lambda, CloudFront) with Nginx
• Own the full lifecycle: requirements → architecture → code → review → deploy → iterate

Next.js React TypeScript TailwindCSS Node.js Express.js MongoDB PostgreSQL AWS Prisma

Industry · Completed phase · Full-time

Focused exclusively on backend engineering for nearly two years — went deep on the server side before touching the frontend. Shipped production REST APIs, built complete authentication systems (JWT, sessions, RBAC), designed databases, and built real-time WebSocket infrastructure with Socket.io.

Key achievements:

• Designed and shipped 10+ production REST APIs with full Swagger documentation
• Built JWT + RBAC authentication systems from scratch used in production
• Architected MongoDB aggregation pipelines reducing query time by 60%
• Built real-time chat and notification systems with Socket.io (1000+ concurrent users)
• Implemented Redis caching layer cutting API response latency by 40%

Node.js Express.js NestJS JWT & RBAC Socket.io MongoDB PostgreSQL Prisma Zod Redis

Self-taught · Origin

Started with C++ and competitive programming — built the engineering mindset before anything else. Transitioned into web development with HTML, CSS, and JavaScript. First Node.js projects sparked a deep interest in backend systems and how the internet works under the hood.

C++ Algorithms HTML / CSS JavaScript Node.js Python

Production-ready Next.js + Node.js starter kit. Ships with everything a SaaS needs from day one: JWT authentication, Stripe payment integration, MongoDB + Mongoose, email verification with Nodemailer, role-based access control, and a clean admin dashboard.

git clone https://github.com/SahilIjaz/saas-boilerplate
cd saas-boilerplate && pnpm install && pnpm dev

Next.js · Node.js · TypeScript · MongoDB · Stripe · JWT · Nodemailer · TailwindCSS

Opinionated Express.js boilerplate that's production-ready out of the box. Includes Zod input validation, rate limiting, auto-generated Swagger/OpenAPI docs, JWT auth middleware, Prisma ORM + PostgreSQL, and structured error handling.

// Fully typed, auto-validated route — body typed and validated by Zod
router.post('/users', validate(createUserSchema), async (req: ValidatedRequest, res) => {
  const user = await UserService.create(req.body);
  res.status(201).json({ success: true, data: user });
});

Express.js · TypeScript · Prisma · PostgreSQL · Swagger · Zod · Jest

Scalable real-time messaging platform with Socket.io. Supports private DMs, group rooms, typing indicators, online presence detection, read receipts, and media file sharing. Clean WebSocket event architecture handles thousands of concurrent connections.

socket.on('message:send', async (payload: MessagePayload) => {
  const message = await MessageService.create(payload);
  io.to(payload.roomId).emit('message:received', message);
  await NotificationService.push(message); // push to offline users
});

Socket.io · React · Node.js · Express.js · MongoDB · TypeScript

Full-featured e-commerce application — product catalog, cart management, order tracking, admin dashboard, customer accounts, Stripe checkout, and AWS S3 media storage. Built with Next.js App Router for performance and real production traffic.

Next.js · Node.js · MongoDB · AWS S3 · Stripe · TailwindCSS · TypeScript

  

1. Backend-first — design the data model and API contract before touching the UI.
   The shape of the data determines everything else in the system.

2. Architecture over shortcuts — a clean foundation takes longer upfront
   and saves weeks later. Technical debt compounds faster than interest.

3. Types everywhere — TypeScript is non-negotiable. Untyped code is
   undocumented code. Types communicate intent across the entire codebase.

4. Security by default — auth, validation, rate limiting, input sanitization.
   These are never afterthoughts. They are designed in from day one.

5. Document as you build — an undocumented API is an incomplete API.
   Swagger specs, README files, and JSDoc comments are first-class deliverables.

6. Ship, then iterate — working software in production beats perfect software
   in development. Get feedback. Improve in the open.

7. Master depth before breadth — went deep on backend for 2 years,
   then expanded to full-stack. Knowing one layer deeply makes you better at all of them.

I'm open to full-time remote roles, freelance projects, open-source collaborations, and technical conversations. If you're building something interesting, reach out.

   

sahil@dev:~/portfolio $ echo "thanks for visiting — let's build something great"
thanks for visiting — let's build something great
sahil@dev:~/portfolio $ █