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.

Gather lightweight evidence about user needs and distinguish observations from 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.

Distinguish the responsibilities and available APIs of JavaScript running in a browser from JavaScript running in Node.js.

Create a Node.js project that uses npm scripts, an installed package, and ES-module imports.

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.

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

Create and inspect a SQLite database from a schema.

Insert validated records using parameterized SQL statements.

Retrieve records using parameterized filters, sorting, and a table join.

Update and delete records safely with parameterized SQL statements.

Access a SQLite database from a Node.js application.

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.

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

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.

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 using secure cookie settings.

Enforce authorization for a protected server operation.

Prevent cross-site scripting by safely rendering untrusted text in HTML.

Protect a session-authenticated form submission with a cross-site request forgery token.

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 without exposing secrets or unrelated files.

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 low-cost environment whose storage model fits the application.

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.

Synthesize lightweight user evidence into an opportunity brief that identifies the target user, problem, intended benefit, assumptions, and a measurable success signal.

Select and bound a capstone idea as a small minimum viable product, explicitly documenting excluded features.

Create a traceability map linking prioritized user stories, acceptance criteria, and the capstone success signal.

Create and validate the capstone’s relational data model against its user stories.

Specify and validate the capstone’s API contract against its essential user workflow and data model.

Prioritize measurable quality scenarios for accessibility, security, reliability, affordability, and resource efficiency, and document relevant technical constraints.

Create context and container diagrams showing the capstone’s users, external systems, runtime parts, data flows, and trust boundaries.

Record the principal capstone architecture choice in an architecture decision record that justifies its simplicity, cost, resource use, and capacity for 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.