Architecture

Use JavaScript values, variables, and operators to calculate and store results.

Control program behavior with conditional statements.

Define and call functions that accept inputs and return outputs.

Process a collection of values using arrays and loops.

Represent a real-world item using a JavaScript object.

Read and update page content through the Document Object Model.

Make a page interactive with browser event listeners.

Locate and correct a JavaScript defect using error messages and browser developer tools.

Write a focused problem statement for a beginner or small-business user.

Separate evidence about user needs from untested product assumptions.

Express one user need as a user story with testable acceptance criteria.

Prioritize candidate features for a minimum viable product using impact and effort.

Diagram the steps a user takes to complete one important task.

Create a low-fidelity wireframe for one application workflow.

Apply accessible HTML labels, headings, keyboard behavior, and alternative text to an interface.

Use responsive CSS to make an interface usable at desktop and mobile widths.

Explain how server-side JavaScript differs from JavaScript running in a browser.

Create a Node.js project and manage its packages and scripts with npm.

Use promises and async/await to handle an asynchronous operation.

Create and run an Express web server.

Implement an Express route that handles an HTTP request.

Send and receive structured JSON data through an API.

Design resource-oriented API endpoints using HTTP methods and status codes.

Return consistent API errors from invalid requests and server failures.

Identify entities, attributes, and relationships from application requirements.

Translate a data model into tables, primary keys, foreign keys, and constraints.

Create and inspect a SQLite database from a schema.

Insert validated records into a relational table.

Query records using filtering, sorting, and a table join.

Update and delete records safely with parameterized SQL statements.

Access a SQLite database from a Node.js application.

Create repeatable scripts that initialize and seed development data.

Request API data from browser code using fetch.

Render loading, empty, success, and error states from API results.

Submit form data from a browser interface to an API endpoint.

Enforce the same essential input rules in the browser and on the server.

Separate route, service, and data-access responsibilities in a Node.js codebase.

Implement one thin feature from browser interaction through API to database.

Diagnose a failed browser-to-server interaction with network developer tools.

Remove duplicated logic while preserving the behavior of a full-stack feature.

Distinguish unit, integration, and end-to-end tests by the boundary each test exercises.

Write a unit test for a JavaScript function.

Write an integration test for an API route.

Test data-access behavior against an isolated test database.

Derive test cases from a user story’s acceptance criteria.

Handle an expected failure without hiding unexpected programming errors.

Configure automated formatting and linting for a JavaScript project.

Refactor a tested function into clearer names and smaller responsibilities.

Distinguish software architecture decisions from detailed design and implementation choices.

Separate functional requirements from quality requirements and technical constraints.

Write a measurable quality-attribute scenario for one system concern.

Draw a system-context diagram showing users, the application, and external systems.

Draw a container diagram showing the application’s major runtime parts and data flows.

Evaluate a code boundary using coupling, cohesion, and responsibility.

Compare a layered monolith, modular monolith, and microservices against a small product’s needs.

Record a consequential technical choice and its trade-offs in an architecture decision record.

Identify assets, entry points, and trust boundaries in a simple web application.

Store passwords using an established password-hashing library.

Implement session-based sign-in and sign-out for a web application.

Enforce authorization for a protected server operation.

Prevent one common injection or cross-site scripting vulnerability through safe data handling.

Minimize personal-data collection and define a retention rule for stored user information.

Explain how computation, storage, and network usage affect operating cost and environmental impact.

Choose a simpler, lower-resource architecture when it satisfies the required quality attributes.

Separate environment-specific configuration and secrets from application source code.

Publish a project to a remote Git repository using a controlled commit history.

Configure a continuous-integration check that runs the project’s automated tests.

Compare low-cost hosting options against traffic, persistence, maintenance, and budget constraints.

Deploy a tested Node.js application to a suitable low-cost hosting environment.

Add a health check and structured diagnostic logging to a deployed application.

Use logs and basic service metrics to diagnose a production failure.

Perform and verify a backup-and-restore procedure for application data.

Gather evidence about one challenge faced by beginners or small businesses.

Define the capstone’s target user, problem, intended benefit, and measurable success signal.

Select and bound a capstone idea that can be delivered as a small minimum viable product.

Write prioritized capstone user stories with acceptance criteria.

Create the capstone’s relational data model.

Specify the capstone’s API contract for its essential workflow.

Create context and container diagrams for the proposed capstone architecture.

Justify the capstone architecture in terms of simplicity, accessibility, cost, resource use, and future change.

Break the capstone into ordered, independently testable vertical slices.

Implement the smallest end-to-end capstone feature from interface to database.

Implement a second capstone feature without violating the chosen module boundaries.

Verify the capstone’s essential workflow with automated and exploratory tests.

Deploy the capstone and verify its health in the production environment.

Use production evidence to diagnose and correct one capstone defect.

Review the delivered architecture against its quality scenarios and constraints.

Write a practical roadmap for evolving the capstone without premature complexity.