Software Engineering

Configure a code editor, Node.js, and Git on a local computer and verify each installation.

Use a terminal to navigate directories and create, move, rename, and delete files and folders.

Run a JavaScript file with Node.js and inspect program output in the console.

Declare variables with let and const and distinguish JavaScript primitive value types.

Evaluate expressions using arithmetic, comparison, logical, and assignment operators.

Control program execution with if, else if, else, and switch statements.

Repeat operations with for and while loops while avoiding common infinite-loop errors.

Define and call functions that use parameters, return values, and local variables.

Create, access, update, and iterate through JavaScript arrays.

Create and update objects using properties, methods, and computed property access.

Transform, filter, locate, and aggregate array values with standard array methods.

Extract and combine array and object data with destructuring, rest, and spread syntax.

Predict how lexical scope affects variable access inside nested functions.

Split a JavaScript program into reusable ES modules with import and export.

Explain how promises represent the eventual result or failure of an asynchronous operation.

Handle asynchronous operations and failures with async, await, try, and catch.

Use stack traces, logging, and an interactive debugger to locate a JavaScript defect.

Create a package.json file and manage project dependencies and scripts with npm.

Organize related behavior into small modules with clear inputs and outputs.

Write automated unit tests for pure JavaScript functions.

Initialize a Git repository and inspect, stage, commit, and restore changes.

Develop a change on a Git branch and merge it into another branch.

Resolve a simple Git merge conflict without losing the intended changes.

Publish a repository to GitHub and use a pull request to review and merge a change.

Determine the time and space complexity of simple algorithms using Big-O notation.

Use Map and Set to implement efficient membership checks and frequency counts.

Solve an array or string problem with the two-pointer technique.

Implement stack and queue behavior and select an appropriate use case for each.

Trace and implement a recursive solution with a correct base case.

Insert, locate, and remove nodes in a singly linked list.

Implement binary search on sorted data and state its required precondition.

Traverse a binary tree using depth-first and breadth-first strategies.

Structure a web page with semantic HTML elements and valid document hierarchy.

Build an accessible HTML form using labels, appropriate controls, and native validation.

Predict element sizing and spacing using the CSS box model and cascade.

Construct a one-dimensional page layout with CSS Flexbox.

Create a responsive two-dimensional layout with CSS Grid and media queries.

Select and modify page elements through the browser Document Object Model.

Respond to browser events and process form submissions with JavaScript.

Audit a web page for keyboard access, meaningful structure, and readable contrast.

Configure a strict TypeScript project and compile it to executable JavaScript.

Annotate variables, arrays, objects, function parameters, and return values with TypeScript types.

Model structured data with type aliases and interfaces.

Represent alternatives with union types and narrow them using runtime checks.

Use generics to preserve type information in a reusable function.

Safely handle nullable values and errors typed as unknown.

Install and use type declarations for a third-party npm package.

Refactor a JavaScript module into TypeScript while preserving its behavior.

Describe an HTTP request and response in terms of method, URL, headers, body, and status code.

Inspect and reproduce HTTP requests with browser developer tools and a command-line client.

Read configuration from environment variables and use Node.js built-in modules.

Create a basic HTTP server with Node.js and return a JSON response.

Define Express routes that use path parameters and query parameters.

Receive and validate a JSON request body in an Express route.

Use Express middleware to perform shared processing across routes.

Return consistent errors from asynchronous routes through centralized error-handling middleware.

Create a local PostgreSQL database and connect to it with a database client.

Model entities and relationships using primary keys, foreign keys, and cardinality.

Create tables whose constraints enforce required values, uniqueness, and referential integrity.

Insert, update, and delete rows with SQL statements.

Retrieve filtered, sorted, and paginated records with SELECT queries.

Combine related records with inner and outer joins.

Summarize grouped data with SQL aggregate functions and HAVING clauses.

Use indexes and query plans to diagnose a slow lookup.

Configure a reusable PostgreSQL connection pool without exposing credentials in source control.

Execute parameterized SQL queries from Node.js to prevent SQL injection.

Separate an Express resource into routing, service, and data-access responsibilities.

Create and apply a database migration and populate development data with a seed script.

Use a database transaction to preserve consistency across a multi-step operation.

Hash and verify passwords and establish an authenticated user session.

Enforce login and resource-level authorization through Express middleware.

Configure cross-origin access, secure cookies, security headers, rate limits, and secret handling for an API.

Create React function components that receive typed props.

Manage local interface state and respond to user events with React hooks.

Build a controlled React form and display field-level validation feedback.

Render conditional content and keyed lists from application data.

Fetch API data in a React component while representing loading, success, and failure states.

Map URLs to application views with client-side routing.

Submit authenticated create, update, and delete requests from React and synchronize the displayed data.

Diagnose a failed full-stack interaction using browser network traces and server logs.

Write unit tests for backend service logic using test doubles at external boundaries.

Write integration tests for Express endpoints against isolated test data.

Test React behavior from a user's perspective with React Testing Library.

Automate formatting, linting, type checking, and tests through project scripts.

Package a Node.js application in a production-oriented Docker image.

Run an application and PostgreSQL together with Docker Compose.

Create a continuous-integration workflow that checks each proposed code change.

Deploy a full-stack application with managed configuration and verify it through health checks and logs.

Extract recurring technical and collaboration requirements from a sample of US junior full-stack and backend job postings.

Define a portfolio project as prioritized user stories with testable acceptance criteria.

Produce a data model and API contract for the portfolio project's core workflow.

Audit the portfolio project against functional, security, accessibility, testing, and deployment checklists.

Write a repository README that explains setup, architecture, features, API usage, and technical trade-offs.

Deliver a concise project walkthrough that explains one engineering challenge and the reasoning behind its solution.

Solve a timed entry-level coding problem while explaining the approach, complexity, and test cases.

Tailor a one-page resume to a specific junior backend or full-stack job description.