Full-Stack Web Development

Create and run a React application with Vite.

Translate a static interface into a hierarchy of React components.

Pass application data into a component through props.

Manage a component value with the `useState` hook.

Update React state in response to a user event.

Render a collection with stable React keys.

Render different interface states with conditional JSX.

Lift shared state to the nearest common parent component.

Build a controlled form with React state.

Validate form fields and display field-specific feedback.

Use `useEffect` to synchronize a component with an external system.

Load API data from an effect without creating an infinite request loop.

Represent loading, success, empty, and failure states in the interface.

Cancel an obsolete browser request with `AbortController`.

Extract reusable stateful behavior into a custom React hook.

Diagnose an incorrect effect by analyzing its dependency array.

Configure client-side routes with React Router.

Read route parameters to render resource-specific pages.

Build a nested layout with child routes.

Share cross-tree state with React Context.

Model multi-action local state with `useReducer`.

Create a Redux Toolkit store and feature slice.

Load remote data with a Redux Toolkit asynchronous thunk.

Lazy-load a route to reduce the initial JavaScript bundle.

Explain how the Node.js event loop handles non-blocking I/O.

Separate an Express application into routers, controllers, services, and data-access code.

Implement an asynchronous Express route handler.

Implement reusable request-logging middleware.

Route operational errors to centralized Express error middleware.

Load and validate environment-specific configuration.

Debug a running Node.js process with breakpoints and stack traces.

Shut down an HTTP server gracefully after receiving a termination signal.

Translate a feature requirement into REST resources and endpoint paths.

Select an appropriate HTTP method for a REST operation.

Return status codes that accurately describe an API result.

Validate request parameters, query strings, and bodies at the API boundary.

Implement cursor- or page-based pagination for a collection endpoint.

Implement filtering and sorting through query parameters.

Accept and validate a multipart file upload.

Document an endpoint with an OpenAPI specification.

Define Mongoose schema constraints that protect document integrity.

Choose between embedding and referencing for a stated relationship.

Construct a Mongoose query with projection and `lean()`.

Resolve a referenced relationship with Mongoose population.

Create an index that supports a specified query pattern.

Build a MongoDB aggregation pipeline for a summary report.

Use a transaction for a multi-document consistency requirement.

Interpret an MongoDB query execution plan to identify an inefficient query.

Store user passwords with a salted password hash.

Issue a signed access token after successful authentication.

Rotate refresh tokens using secure HTTP-only cookies.

Authenticate an Express request with token-verification middleware.

Enforce role-based authorization on a protected API operation.

Implement a time-limited password-reset token flow.

Configure credentialed cross-origin requests for an approved frontend origin.

Protect a cookie-authenticated state-changing request from CSRF.

Create a reusable frontend client for the application API.

Represent the signed-in user consistently across the React application.

Redirect unauthenticated users away from protected client routes.

Connect a React feature to create, read, update, and delete API operations.

Apply an optimistic interface update with rollback on request failure.

Reject NoSQL injection payloads at the API boundary.

Configure security headers and request rate limits in Express.

Upload a file from React and store its resulting metadata through the API.

Write a unit test for an isolated service function.

Test an Express endpoint with Supertest.

Isolate MongoDB state between integration tests.

Test a React component with React Testing Library.

Test a React user interaction with `user-event`.

Mock a browser API response with Mock Service Worker.

Automate a critical browser workflow with an end-to-end test.

Run linting and automated tests in a continuous-integration workflow.

Annotate JavaScript values and function signatures with TypeScript types.

Define reusable object shapes with interfaces and type aliases.

Narrow a union type safely before using a value.

Create a generic function that preserves input-output type relationships.

Type React component props, state, and event handlers.

Type an Express request handler and custom request property.

Define TypeScript types for a Mongoose model.

Enable strict TypeScript checking and resolve errors during incremental migration.

Convert a capstone idea into prioritized user stories with acceptance criteria.

Draw a deployment architecture for the React client, Express API, and MongoDB database.

Manage production configuration without exposing secrets.

Containerize an Express API with Docker.

Deploy the API with a managed MongoDB database.

Deploy the React client and configure production API access.

Add structured server logging and production error monitoring.

Write a portfolio README and justify key technical trade-offs in a project walkthrough.