No-Code Backend Development

Initialize a Git repository with a Java-appropriate .gitignore that excludes credentials, generated files, and IDE metadata.

Stage related changes and create a commit whose message explains one logical change.

Use Git status, diffs, logs, and blame to identify when and why an AI-generated change entered the codebase.

Create a feature branch to isolate an AI-generated change from the main branch.

Resolve a simple merge conflict without discarding valid code from either side.

Restore a file or revert a commit after an AI-generated change proves unsafe.

Push a feature branch to GitHub and merge it through a reviewed pull request.

Create a CLAUDE.md file that states the stack, architecture rules, coding conventions, verification commands, and forbidden changes.

Convert an e-commerce feature request into explicit, testable acceptance criteria before asking Claude Code to implement it.

Restrict Claude Code's repository context and tool permissions to what a specific backend task requires.

Request and evaluate an implementation plan before allowing Claude Code to modify the repository.

Review an AI-generated diff for unintended file changes, exposed secrets, weak validation, unnecessary dependencies, and architectural violations.

Correct a localized defect in AI-generated Java code and verify the correction with the Maven build.

Define the first production release in terms of actors, use cases, constraints, acceptance boundaries, and out-of-scope features.

Model the relationships and lifecycle boundaries among users, products, inventory, carts, orders, and payments.

Define and justify transaction boundaries for catalog updates, cart operations, checkout, and payment updates.

Create versioned PostgreSQL tables, relationships, and constraints with Flyway migrations.

Review and correct AI-generated JPA mappings for ownership, fetch behavior, cascading, and enum persistence.

Define an OpenAPI contract for the release's authentication, catalog, cart, order, payment, and error responses.

Verify that the generated package structure separates web, application, domain, and persistence responsibilities.

Implement product creation and update APIs using request and response DTOs while enforcing SKU, price, and status invariants.

Implement paginated product search with filtering and deterministic sorting.

Add PostgreSQL indexes for the catalog's actual filtering and sorting queries and verify their use with a query plan.

Implement stock increases and decreases while enforcing the nonnegative inventory invariant.

Make stock deduction concurrency-safe with optimistic locking or a conditional database update, then demonstrate that competing requests cannot oversell a product.

Explain the request path through Spring Security's filter chain for a protected API endpoint.

Implement customer registration with input validation, unique identity enforcement, and adaptive password hashing.

Configure stateless Spring Security rules for public, customer, and administrator endpoints.

Issue a signed, time-limited JWT after validating login credentials.

Validate JWT signatures, expiration, and required claims before establishing an authenticated request.

Enforce customer and administrator permissions at the service layer with method security.

Configure CORS for named frontend origins without permitting arbitrary credentialed origins.

Implement owner-scoped cart item addition and quantity changes while rejecting access to another customer's cart.

Calculate cart totals on the server without trusting product identifiers, prices, or totals supplied by a client.

Create an immutable order price snapshot so later catalog changes cannot alter an existing order.

Represent order and payment progress with explicit states and reject invalid state transitions.

Integrate a simulated payment service behind an application interface so payment behavior can be replaced or mocked.

Implement checkout as a transaction that creates an order and deducts inventory consistently.

Make checkout safe to retry by enforcing an idempotency key and returning the original result for repeated requests.

Authenticate and process a simulated payment callback exactly once, applying valid success or failure transitions and restoring inventory when required.

Classify a backend behavior as suitable for a unit, web-slice, repository, or end-to-end integration test.

Write a JUnit test for a pricing, inventory, or order-state business rule.

Use Mockito to isolate an application service from the simulated payment dependency.

Write a Spring MVC test for validation, authorization, and response-status behavior.

Use Testcontainers to test a repository and its Flyway migrations against PostgreSQL rather than an in-memory substitute.

Write an integration test that covers authenticated checkout through database commit and verifies repeated use of the same idempotency key.

Diagnose and repair an AI-generated test that passes for the wrong reason or fails nondeterministically.

Return a consistent error response containing a stable code, safe message, timestamp, and request identifier.

Add correlation identifiers and structured logs that trace one checkout request across application layers.

Expose health and readiness information without leaking sensitive configuration.

Record application metrics for request failures, checkout outcomes, and payment latency.

Apply a timeout and bounded retry policy only to simulated payment operations that are safe to retry.

Apply bounded rate limits to sensitive operations such as login and checkout, returning an appropriate response when limits are exceeded.

Run dependency and secret scans, investigate the results, and remediate one concrete finding.

Separate local, test, and production settings with Spring profiles and external configuration.

Load database credentials, JWT signing material, and other secrets from environment variables without committing them to Git.

Build a multi-stage Docker image that runs the Spring Boot application as a non-root user.

Create a Docker Compose setup for the API and PostgreSQL that successfully applies Flyway migrations to a fresh database.

Diagnose a container startup failure using application logs, environment inspection, container status, and health information.

Create a GitHub Actions workflow that compiles the project and runs unit and web-layer tests on each pull request.

Add Testcontainers-based PostgreSQL integration tests to the continuous-integration workflow.

Build and publish a versioned Docker image only after checks on the main branch pass.

Store registry and deployment credentials using GitHub and cloud-platform secret management.

Provision a managed PostgreSQL database and configure encrypted connectivity from the application.

Deploy the containerized API to a managed cloud platform using production environment configuration.

Run post-deployment smoke tests for health, authentication, catalog access, cart operations, and checkout.

Use deployment logs and the previous known-good image to diagnose and recover from a failed release.

Write a README that lets another developer configure, test, run, and deploy the project.

Create an architecture diagram showing request flow, application boundaries, PostgreSQL, security filters, and the simulated payment dependency.

Explain one design decision involving transaction or consistency boundaries and defend its main trade-off.

Walk through an AI-generated feature change and identify where human judgment corrected or constrained the result.

Demonstrate the deployed API through a concise scenario covering registration, authentication, catalog, cart, checkout, and payment.

Complete a timed Java and Spring backend mock interview using evidence from the project to explain security, testing, persistence, and deployment decisions.