← All projects

Student Job Tracker — A Full-Stack MERN Build, Deploy & Explain Challenge

Source: Derived from Resources/Fullstack Developer TA Intern – MERN Stack Assignment (Cuvette).pdf — a real take-home assessment used by Cuvette (cuvette.tech) to hire a Fullstack Developer TA (Teaching Assistant) Intern on the MERN stack.

Skills Required

Background a Student Needs

A student should already understand core JavaScript (arrays, objects, async/await, promises) and the fundamentals of React (components, props, state, Hooks). They should know how a REST API works conceptually — that a frontend makes HTTP requests to a backend that talks to a database — and have written at least a small Express server and a basic MongoDB/Mongoose model before. Familiarity with Git, the npm ecosystem, and reading platform docs (Vercel, Render, MongoDB Atlas) is important, since deployment is mandatory. No advanced authentication or DSA background is assumed; the algorithm problems here are entry-to-medium level and operate on the same job-application data the app already uses.

Task Summary

Build a "Student Job Tracker" — a full-stack MERN web app where a user can add, list, filter, update, and delete job applications, then deploy it end-to-end (frontend on Vercel, backend on Render/Railway, database on MongoDB Atlas) so it runs live online. In addition, solve one JavaScript DSA problem over job-application data and record a 10–15 minute video walkthrough (camera on) explaining the features, code structure, and approach. An optional bonus section asks you to document how you used AI tools during development.

The Task

Estimated time: 3–4 hours. Objective: demonstrate MERN skills and the ability to explain your work clearly.

Part 1 — Build the "Student Job Tracker" web app (mandatory)

Tech stack: Frontend React (with Hooks); Backend Node.js + Express.js; Database MongoDB (Atlas preferred); Deployment Vercel (frontend) + Render or Railway (backend).

Features to build:

  1. Add Job Application — a form capturing: Company, Role, Status (one of Applied / Interview / Offer / Rejected), Date of Application, and a Link (e.g., to the posting).
  2. List All Applications — display applications in a clean, responsive layout, with filtering by status or date.
  3. Update Status — let the user change an application's status.
  4. Delete Application — let the user remove a job entry.

Deployment (mandatory)

Part 2 — AI Tools & LLMs (bonus)

Use tools like ChatGPT, GitHub Copilot, or similar to support development, then submit: the prompts / ways you used AI, how it helped (or didn't), and the manual changes you made after using the tool.

Part 3 — Video Walkthrough (mandatory)

Record a 10–15 minute screen recording with your camera ON, covering: a feature walkthrough, an explanation of your folder/code structure, your approach and thought process, and any AI-tool usage.

Part 4 — Data Structures & Algorithms in JavaScript

Choose any ONE problem and solve it in JavaScript:

What to submit

Evaluation / bonus points

Graders reward clean, modular code, good UI/UX, effective use of AI tools, and a clear explanation with camera on. Because this is a TA-intern role, the explanation quality (Part 3) carries real weight alongside the working, deployed app.

Alternate Tasks (Mini-Project Variations)

  1. (Beginner) Local-Only Job Tracker with In-Memory or JSON Storage. Strip the challenge down to the React frontend plus a minimal Express backend that stores job applications in a plain in-memory array or a local JSON file (no MongoDB, no deployment). Implement the four CRUD features — add, list, update status, delete — and the status filter. The learning goal here is to cleanly separate concerns: a React form and list on the client, a small set of REST endpoints (GET /jobs, POST /jobs, PATCH /jobs/:id, DELETE /jobs/:id) on the server, and the fetch calls that connect them. This removes the cloud-setup friction so a newer student can focus entirely on understanding the request/response cycle and React state updates before layering on databases and hosting.
  2. (Intermediate) Full MERN Tracker with Atlas + One-Platform Deploy. Rebuild the app faithfully to the original — React + Express + MongoDB Atlas with Mongoose models — but require it to be genuinely deployed and live, exactly as the source assignment demands (Vercel for the frontend, Render or Railway for the backend, Atlas for the database). Add the status/date filtering, proper loading and error states, and environment-variable configuration so no secrets are hard-coded. The core lesson is the often-painful "last mile" of full-stack work: configuring CORS between two different hosted origins, setting environment variables in each platform's dashboard, and debugging a frontend that builds fine locally but can't reach its backend in production. Finish by writing a README that documents the live URLs and local setup steps.
  3. (Intermediate–Advanced) Multi-User Tracker with Authentication & Dashboards. Extend the MERN tracker so each user signs up and logs in (JWT-based auth with bcrypt-hashed passwords), and each user only sees and edits their own job applications via protected routes and userId-scoped queries. Then add an analytics dashboard: server-side aggregation (or client-side computation) that charts how many applications sit in each status and a monthly trend of applications over time, plus pagination and a search bar. This mirrors what real production job-tracker apps look like and pushes the student into authorization, data ownership, MongoDB aggregation, and data visualization — a meaningful step up from a single-user CRUD demo.
  4. (Advanced — MERN depth) Real-Time Collaborative Tracker with Testing & CI. Take the authenticated tracker and make it collaborative and production-hardened. Introduce shared "boards" where multiple users can be invited to the same set of applications, and use WebSockets (Socket.IO) so that when one user updates a status, every connected viewer sees it update live without refreshing. Add input validation (e.g., Zod or Joi) on the backend, write unit tests for the controllers and the DSA utility functions (Jest), add an integration test that hits the API, and wire up a GitHub Actions CI pipeline that runs the test suite on every push. This variation teaches real-time architecture, rigorous validation, and the testing/automation discipline that separates a portfolio toy from employable engineering.
  5. (Advanced — Agentic AI twist) AI Job-Application Copilot Agent. Reframe the tracker as the data layer for an AI agent. Keep the MERN backend and Atlas store of job applications, then build an agent (using an LLM API plus tool/function calling, e.g., via the OpenAI or Anthropic SDK, optionally orchestrated with LangChain) that can take natural-language commands like "add a Software Engineer application at Stripe I applied to yesterday," "show me everything still in the Interview stage," or "which company haven't I heard back from in two weeks?" The agent must call structured tools that map to your existing REST endpoints (add, query, update, delete), parse dates and statuses from free text, and return grounded summaries based only on what's actually in the database. As a stretch, have the agent draft a tailored follow-up email for a chosen application. This bridges the source MERN domain into Agentic AI, teaching tool-calling, prompt design, grounding responses in real data, and safely letting an LLM mutate a database through a controlled API surface.

Reference Links