AWS Builder Center
CareerLens: The Full Story

CareerLens: The Full Story

How I solved a major problem faced by Indian student.

Pre-final year student. AWS Student Builder Campus Leader. Striving to grow and learn.

CareerLens: the full story

20 September 2026 · @simrithi · built solo for WeMakeDevs × AWS First Commit



The story

CareerLens was built solo, joining the hackathon after the clock had already started, and finished across late nights rather than a comfortable runway. Every layer in this write-up, the frontend, the four stack AWS backend, the Lambda functions, the CDK infrastructure and the AI integrations, was designed, written and wired up by one person.
That background is not incidental. I am an AWS Student Builder Campus Leader, selected through an interview process, and I spend a good part of my time teaching and mentoring other students on AWS and cloud fundamentals. That is the same instinct that shaped this build: favour patterns that are explainable and defensible over ones that just barely work. CareerLens is what happens when a teaching mindset gets pointed at a single weekend problem instead of a classroom.



The problem

India produces roughly 10 lakh engineering adjacent graduates a year, chasing a far smaller pool of roles that actually match their skills. The app's own framing is 10 lakh graduates for around 1 lakh openings. Three effects follow from that gap:
Everyone chases the same three or four roles. Full stack, backend, data. Competition on those specific roles runs 10:1 or worse, while adjacent roles with real demand go unfilled.
Students pick careers by hype, not by demand versus supply. There is no easy way to see where graduates are piling up against where openings actually are.
Tier 2 and tier 3 candidates get filtered by pedigree before anyone looks at their skills. Resumes are judged on college name and city before a recruiter ever sees a project.
CareerLens is built around one idea for each side of that gap: give a student a concrete, re plannable roadmap instead of generic advice, and give a recruiter a way to rank candidates on proven skill, with identity blinded until shortlist, so pedigree stops being the first filter.



The product: two portals, one platform

Student portal. A dashboard with a readiness score and next best actions. A roadmap of milestones toward a target role that re plans itself when the student falls behind schedule. A Resume Lab with an ATS readiness checklist, project to role alignment and personalised rejection reason diagnosis. An applications tracker with a drag and drop pipeline and automatic status updates. Rubric scored mock interviews. A Job Market view with real listings, hiring trends and layoff news. And an Innovation Lab of experimental features: Career Pivot Finder, Reality Gap Explorer, Micro Gigs, Layoff and Automation Shield.
Company portal. A hiring overview with funnel and time to shortlist. Talent Match, ranking candidates by skill match and project to role alignment rather than keyword search. Job Postings with skills auto suggested from a role catalogue.
The differentiator on the recruiter side is blind screening: a candidate's name, college and city are withheld until a recruiter shortlists them, and that redaction is enforced server side. The client never receives the PII in the first place, so it cannot be un hidden by reading the frontend code.
Both portals run on the same account model, using Cognito student and company groups, and the same underlying API contract. A recruiter and a candidate are genuinely using the same product, not two demos bolted together.



Architecture: frontend

React 19 and Vite, plain JavaScript, HashRouter so the SPA needs no server side rewrite rule to deploy anywhere static. framer motion for motion, recharts for charts, lucide react for icons.
The structural decision that matters most: pages never touch data directly. Every page calls a function in  src/api/*.js , namely  authApi ,  profileApi ,  roadmapApi ,  applicationsApi ,  interviewApi ,  marketApi ,  featuresApi  and  recruiterApi , and stores the result through a single  useData().run(...)  call.
Those files are the backend contract. Each function is written once, and a  VITE_USE_MOCK  flag decides at runtime whether it resolves against a local mock backed by localStorage, or a real HTTP call to API Gateway.
That one flag is what let a solo build ship two working demo paths instead of one. The whole product works fully offline against realistic seed data, and swapping in the real AWS backend is a single environment variable. No page was ever rewritten.
 src/api/engine.js  holds the deterministic logic, including skill matching, ATS scoring, readiness and resilience scoring, and every function in it is commented with the exact AWS service that replaces or augments it in production, which doubles as the project's own scaling roadmap.



Architecture: backend

Architecture

A TypeScript AWS CDK app, four stacks deployed to one account: Auth, Api, Data and Guardrails.
  • Cognito user pool with student and company groups, hosted UI and PKCE.
  • API Gateway HTTP API with a JWT authorizer in front of one Lambda per route.
  • DynamoDB, single table design. Every entity, including profile, roadmap, applications, interviews, company data, candidates, shortlists and gigs, lives under one  PK=USER#{userId}  partition per account.  PK=GIGS  and  PK=MARKET  are the two deliberate exceptions, for data shared across every user rather than scoped to one.
  • S3 for resumes, encrypted, with presigned uploads.
  • Secrets Manager for external API keys.
  • EventBridge for scheduled work.
Every Lambda is bundled with esbuild through CDK's  NodejsFunction , runs on  NODEJS_24_X , and gets IAM permissions scoped to exactly what it touches:  table.grantReadData  versus  grantReadWriteData  per function, secret access only where a function needs it. No wildcard policies.



AI, and real external data

AI is scoped deliberately, not sprinkled everywhere. Everything that is pure maths over data already in hand, such as skill matching, ATS scoring, readiness and resilience scoring, stays deterministic code, because a hiring adjacent score should be explainable rather than a black box.
Amazon Bedrock was not authorised on this AWS account, so Gemini fills that role instead, and it writes the phrasing for exactly three things:
  1. Why a resume might get rejected
  1. How a mock interview answer scores against a rubric
  1. A one line rationale when the roadmap re plans itself
Every one of those three calls degrades to a local fallback on failure. An AI provider outage never breaks a live demo session.
The external data is real, not fabricated. Job listings and a hiring trend index come from Adzuna's free tier job search API. Hiring and layoff news headlines come from GNews. Both are cached in DynamoDB with a 30 minute TTL ( lambda/common/marketCache.ts ) to stay inside free tier quotas regardless of traffic, and both fall back to local sample data if the live call fails, so a flaky external API never blanks the Job Market page.
On top of that lazy cache, an EventBridge scheduled rule ( LayoffNewsRefreshRule , every 30 minutes) proactively refreshes the layoffs news cache instead of waiting for a visitor to trigger the first slow call. Production style cache warming, not just cache on read.



Engineering discipline

A few decisions that came from treating this like production software under a deadline rather than a throwaway demo.
Graceful degradation is the default, not an afterthought. Every real mode API call that talks to an external service or an optional backend stack has an explicit fallback: to sample data, to a local heuristic, or for the recruiter portal to the same seed data that mock mode uses. A partially deployed backend never means a blank screen for a judge clicking through.
 userId  is never trusted from the client. Every Lambda derives the authenticated user from the Cognito JWT's  sub  claim server side. A request body or path parameter can claim to be anyone; the Lambda never believes it.
Blind screening is enforced where it cannot be bypassed. Candidate PII is stripped server side before a response leaves the Lambda for a non shortlisted candidate, rather than hidden then shown by frontend CSS.
A written API contract ( docs/api-contract.md ,  docs/openapi.yaml ) documents every endpoint, its request and response slice, and which logic is deterministic versus AI backed, written so the mock and the real backend stay interchangeable without touching a single page component.
Cost guardrails came before the first deploy. A CloudWatch billing alarm was live before any Lambda was.
None of this was required to make a demo look finished. It was the difference between a demo that survives a live click through and one that only survives a rehearsed one.



What is real, and what is honestly illustrative

The project holds itself to two rules, enforced in the codebase itself.
Market numbers and sample companies are illustrative, never presented as real statistics. Job listings, hiring trends and news headlines from Adzuna and GNews are real. The demo account companies, candidate rosters and funnel metrics are labelled as sample data in the UI itself, with "Sample metrics for the demo" visible to the user rather than buried in a README.
Every score is an estimate, never a probability of being hired. ATS readiness, skill match and resilience are all deterministic, all explainable, and none of them claim to predict a hiring outcome.
That distinction matters more than it sounds. It is easy to make a hackathon demo feel more impressive by blurring the line between real data and data that looks real. CareerLens draws that line on purpose and keeps it visible to the user, not just to a judge reading the source.



Why this, why like this

Every piece of this, the mock and real toggle, the AI fallbacks, the blind screening, and the budget alarm set up before the first Lambda, exists because a solo builder working through the night does not get a second pass to fix what breaks live.
It would have been faster to fake more of it. But the bar I built to was degrade honestly instead of breaking, which turned out to be a harder and more interesting problem than the one the hackathon actually asked.
I wanted to ship it, tried my best but there are constant errors!
tools used: claude code
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article