Shreya Pathak

Shreya Pathak, Hello

(full stack developer)

2026

About me

[ your photo ]

Hello, my name is

Shreya Pathak

a full stack developer specialising in scalable web apps, APIs, cloud infrastructure, and clean user interfaces.

I believe every product has its own logic, and my goal is to turn it into software that feels fast, reliable, and effortless to use. I enjoy taking messy requirements and shaping them into systems that are simple to reason about and pleasant to build on.

My approach is clean, intentional, and detail-oriented, from database schema to the last pixel.

Experience

2024 — Present
Senior Full Stack Developer
[Company A]
Building a multi-tenant analytics platform used by 300+ teams.
2022 — 2024
Full Stack Developer
[Company B]
Shipped checkout, payments and internal tools for an e-commerce group.
2020 — 2022
Frontend Developer
[Agency C]
Built marketing sites and design systems for 20+ clients.

Stack

Frontend
React, Next.js, TypeScript, Tailwind
Backend
Node.js, tRPC, GraphQL, Go
Databases
PostgreSQL, Redis, Prisma
Cloud & DevOps
AWS, Docker, GitHub Actions

Tools

VS Code
Git & GitHub
Docker
Postman
Figma
Vercel / AWS

Education

BSc Computer Science
[University]
2016 — 2020
AWS Certified Developer
Associate
2023

Contacts

Web Applications

(02 projects)

FrontendREST & GraphQLAuthDatabase designReal-timeCI/CDTestingCloud deploy

Nimbus Analytics

(SaaS Dashboard)

Project goal:

Product teams at 300+ companies were drowning in CSV exports. They needed a real-time analytics dashboard that answers everyday questions in under a second, with no data team in the loop.

Tech decisions:

Next.js for SSR and streaming, tRPC for type-safe APIs end to end, and a Redis cache in front of Postgres materialized views to cut response time. Hosted on AWS with per-tenant rate limits.

Results:

−45% load time
12k weekly users
99.95% uptime

Next.js
tRPC
PostgreSQL
Redis
AWS

Live site ↗GitHub ↗

nimbusanalytics.app

Nimbus Analytics

saas dashboard

(in use)

ship it ✓

server/routers/metrics.ts

export const metricsRouter = router({
  overview: protectedProcedure
    .input(z.object({ range: z.enum(["7d", "30d", "90d"]) }))
    .query(async ({ ctx, input }) => {
      const key = "overview:" + ctx.org.id + ":" + input.range;
      const cached = await redis.get(key);
      if (cached) return JSON.parse(cached);

      const data = await db.metrics.aggregate(ctx.org.id, input.range);
      await redis.set(key, JSON.stringify(data), "EX", 60);
      return data;
    }),
});export const metricsRouter = router({
  overview: protectedProcedure
    .input(z.object({ range: z.enum(["7d", "30d", "90d"]) }))
    .query(async ({ ctx, input }) => {
      const key = "overview:" + ctx.org.id + ":" + input.range;
      const cached = await redis.get(key);
      if (cached) return JSON.parse(cached);

      const data = await db.metrics.aggregate(ctx.org.id, input.range);
      await redis.set(key, JSON.stringify(data), "EX", 60);
      return data;
    }),
});export const metricsRouter = router({
  overview: protectedProcedure
    .input(z.object({ range: z.enum(["7d", "30d", "90d"]) }))
    .query(async ({ ctx, input }) => {
      const key = "overview:" + ctx.org.id + ":" + input.range;
      const cached = await redis.get(key);
      if (cached) return JSON.parse(cached);

      const data = await db.metrics.aggregate(ctx.org.id, input.range);
      await redis.set(key, JSON.stringify(data), "EX", 60);
      return data;
    }),
});

(architecture)

nimbusanalytics.app/settings

read the case study ↗

Crate & Co.

(E-commerce Platform)

Project goal:

A growing homeware brand had outgrown its template store. It needed a fast, custom storefront and a checkout it could trust when a new collection drops.

Tech decisions:

Next.js with incremental regeneration for product pages, Stripe Checkout and webhooks for payments, a Node order service with a job queue, and PostgreSQL as the single source of truth for stock.

Results:

+27% conversion
0.9s LCP on mobile
0 oversold items

Next.js
Stripe
Node.js
PostgreSQL
Vercel

Live site ↗GitHub ↗

crateandco.app

Crate & Co.

e-commerce platform

(in use)

ship it ✓

app/api/webhooks/stripe/route.ts

export async function POST(req: Request) {
  const sig = req.headers.get("stripe-signature")!;
  const event = stripe.webhooks.constructEvent(
    await req.text(), sig, process.env.STRIPE_WEBHOOK_SECRET!
  );

  if (event.type === "checkout.session.completed") {
    const session = event.data.object;
    await db.order.update({
      where: { checkoutId: session.id },
      data: { status: "paid", paidAt: new Date() },
    });
    await queue.add("send-receipt", { orderId: session.metadata.orderId });
  }
  return new Response("ok");
}export async function POST(req: Request) {
  const sig = req.headers.get("stripe-signature")!;
  const event = stripe.webhooks.constructEvent(
    await req.text(), sig, process.env.STRIPE_WEBHOOK_SECRET!
  );

  if (event.type === "checkout.session.completed") {
    const session = event.data.object;
    await db.order.update({
      where: { checkoutId: session.id },
      data: { status: "paid", paidAt: new Date() },
    });
    await queue.add("send-receipt", { orderId: session.metadata.orderId });
  }
  return new Response("ok");
}export async function POST(req: Request) {
  const sig = req.headers.get("stripe-signature")!;
  const event = stripe.webhooks.constructEvent(
    await req.text(), sig, process.env.STRIPE_WEBHOOK_SECRET!
  );

  if (event.type === "checkout.session.completed") {
    const session = event.data.object;
    await db.order.update({
      where: { checkoutId: session.id },
      data: { status: "paid", paidAt: new Date() },
    });
    await queue.add("send-receipt", { orderId: session.metadata.orderId });
  }
  return new Response("ok");
}

(architecture)

crateandco.app/settings

read the case study ↗

Real-time & AI

(02 projects)

WebSocketsPub/SubStreamingVector searchPresenceRate limitsEdge functionsObservability

Relay

(Real-time Chat)

Project goal:

A remote-first community wanted a chat app it owned, with channels, threads and presence, that feels instant even with thousands of people online.

Tech decisions:

A Node WebSocket gateway scaled horizontally with Redis Pub/Sub, optimistic UI in React, messages persisted in Postgres, and everything shipped as Docker containers.

Results:

<80ms message latency
50k messages / min
4.8★ app rating

React
Node.js
WebSockets
Redis
Docker

Live site ↗GitHub ↗

relaychat.app

Relay

real-time chat

(in use)

ship it ✓

realtime/server.ts

wss.on("connection", (socket, req) => {
  const user = authenticate(req);

  socket.on("message", async (raw) => {
    const msg = MessageSchema.parse(JSON.parse(raw.toString()));
    await db.message.create({ data: { ...msg, authorId: user.id } });
    // fan out to every gateway node in the cluster
    await pub.publish("room:" + msg.roomId, JSON.stringify(msg));
  });
});

sub.on("message", (channel, payload) => {
  rooms.get(channel)?.forEach((s) => s.send(payload));
});wss.on("connection", (socket, req) => {
  const user = authenticate(req);

  socket.on("message", async (raw) => {
    const msg = MessageSchema.parse(JSON.parse(raw.toString()));
    await db.message.create({ data: { ...msg, authorId: user.id } });
    // fan out to every gateway node in the cluster
    await pub.publish("room:" + msg.roomId, JSON.stringify(msg));
  });
});

sub.on("message", (channel, payload) => {
  rooms.get(channel)?.forEach((s) => s.send(payload));
});wss.on("connection", (socket, req) => {
  const user = authenticate(req);

  socket.on("message", async (raw) => {
    const msg = MessageSchema.parse(JSON.parse(raw.toString()));
    await db.message.create({ data: { ...msg, authorId: user.id } });
    // fan out to every gateway node in the cluster
    await pub.publish("room:" + msg.roomId, JSON.stringify(msg));
  });
});

sub.on("message", (channel, payload) => {
  rooms.get(channel)?.forEach((s) => s.send(payload));
});

(architecture)

relaychat.app/settings

read the case study ↗

Muse Studio

(AI Writing Tool)

Project goal:

Content teams wanted AI help that sounds like their brand. The goal was a writing tool grounded in their own documents and style guide, with sources they can check.

Tech decisions:

Retrieval over the team's documents with pgvector, responses streamed token by token from an LLM API through a Next.js route handler, and prompt caching to keep costs predictable.

Results:

3× faster first drafts
9k monthly users
−60% token cost

Next.js
TypeScript
pgvector
LLM API
Vercel

Live site ↗GitHub ↗

musestudio.app

Muse Studio

ai writing tool

(in use)

ship it ✓

app/api/draft/route.ts

export async function POST(req: Request) {
  const { prompt, docId } = await req.json();
  const context = await vectorSearch(docId, prompt, { k: 6 });

  const stream = await llm.stream({
    system: STYLE_GUIDE,
    messages: [{ role: "user", content: withContext(prompt, context) }],
  });

  return new Response(stream.toReadableStream(), {
    headers: { "Content-Type": "text/event-stream" },
  });
}export async function POST(req: Request) {
  const { prompt, docId } = await req.json();
  const context = await vectorSearch(docId, prompt, { k: 6 });

  const stream = await llm.stream({
    system: STYLE_GUIDE,
    messages: [{ role: "user", content: withContext(prompt, context) }],
  });

  return new Response(stream.toReadableStream(), {
    headers: { "Content-Type": "text/event-stream" },
  });
}export async function POST(req: Request) {
  const { prompt, docId } = await req.json();
  const context = await vectorSearch(docId, prompt, { k: 6 });

  const stream = await llm.stream({
    system: STYLE_GUIDE,
    messages: [{ role: "user", content: withContext(prompt, context) }],
  });

  return new Response(stream.toReadableStream(), {
    headers: { "Content-Type": "text/event-stream" },
  });
}

(architecture)

musestudio.app/settings

read the case study ↗

APIs & Backend

(01 project)

Schema designGraphQLCachingPaginationRate limitingSDKsDocsLoad testing

Atlas API

(Public API Platform)

Project goal:

Partners were scraping the dashboard because there was no API. The goal was a public GraphQL and REST platform with keys, docs and fair limits.

Tech decisions:

A GraphQL gateway with DataLoader batching to kill N+1 queries, cursor pagination, token-bucket rate limiting at the edge, and generated TypeScript SDKs. Runs on Kubernetes.

Results:

2B requests / month
42ms p99 latency
600+ developers

Node.js
GraphQL
PostgreSQL
Kubernetes

Live site ↗GitHub ↗

atlasapi.app

Atlas API

public api platform

(in use)

ship it ✓

graphql/resolvers/project.ts

export const Project = {
  // batched: one query per request, not one per row
  owner: (project, _args, { loaders }) =>
    loaders.user.load(project.ownerId),

  deployments: async (project, { first = 20, after }, { db }) => {
    const rows = await db.deployment.findMany({
      where: { projectId: project.id },
      take: first + 1,
      cursor: after ? { id: decode(after) } : undefined,
    });
    return toConnection(rows, first);
  },
};export const Project = {
  // batched: one query per request, not one per row
  owner: (project, _args, { loaders }) =>
    loaders.user.load(project.ownerId),

  deployments: async (project, { first = 20, after }, { db }) => {
    const rows = await db.deployment.findMany({
      where: { projectId: project.id },
      take: first + 1,
      cursor: after ? { id: decode(after) } : undefined,
    });
    return toConnection(rows, first);
  },
};export const Project = {
  // batched: one query per request, not one per row
  owner: (project, _args, { loaders }) =>
    loaders.user.load(project.ownerId),

  deployments: async (project, { first = 20, after }, { db }) => {
    const rows = await db.deployment.findMany({
      where: { projectId: project.id },
      take: first + 1,
      cursor: after ? { id: decode(after) } : undefined,
    });
    return toConnection(rows, first);
  },
};

(architecture)

atlasapi.app/settings

read the case study ↗

More work

(archive)

portfolio 2026full stack developer

Thank you!

I'm currently available for freelance projects, collaborations, and new opportunities.

Feel free to get in touch.

design & code by Shreya Pathak