Backend Kotlin

Configure a JDK, IntelliJ IDEA, and Gradle to run a Kotlin application.

Use Kotlin variables, basic types, operators, and console input to process user data.

Use conditional expressions and loops to implement command-driven program behavior.

Decompose a Kotlin program into functions with typed parameters and return values.

Apply Kotlin null-safety operators to handle missing input without null-pointer failures.

Use mutable and read-only collections to store and retrieve application data.

Model task states with data classes and enums.

Implement a command-line task tracker that can add, list, update, and remove in-memory tasks.

Encapsulate state and behavior in Kotlin classes.

Use interfaces and composition to make implementations replaceable.

Write Kotlin lambda expressions using trailing-lambda syntax and the implicit it parameter.

Transform, group, and aggregate Kotlin collections using map, filter, groupBy, and fold.

Use sealed classes and exhaustive when expressions to represent operation results.

Catch expected exceptions and define custom exceptions for invalid operations.

Read and write structured application data using files.

Represent dates with Java Time types and monetary values with BigDecimal.

Use Git status, add, commit, diff, and log to manage source history.

Create and merge a Git branch for an isolated feature.

Configure Gradle plugins, dependencies, and build tasks for a Kotlin project.

Organize Kotlin code into packages with clear visibility boundaries.

Write JUnit tests for deterministic Kotlin functions.

Use breakpoints and stack traces to diagnose a failing Kotlin program.

Implement a small feature using the red-green-refactor testing cycle.

Implement a command-line expense analyzer that imports transactions and summarizes spending.

Trace how an HTTP request becomes a response through clients, servers, methods, headers, and status codes.

Design resource-oriented endpoints for a small REST API.

Create and run a Kotlin Spring Boot web application.

Use constructor injection to connect Spring-managed components.

Define request and response DTOs that serialize to and deserialize from JSON.

Implement controller endpoints that bind path, query, and body inputs.

Send and inspect API requests with an HTTP client such as curl or Postman.

Implement an in-memory REST API for creating, listing, and deleting bookmarks.

Separate HTTP, business, and data-access responsibilities into controller, service, and repository layers.

Implement create, read, update, and delete use cases behind a service interface.

Map API data-transfer objects to domain objects without exposing internal models.

Validate request fields and reject invalid input with appropriate HTTP responses.

Translate domain failures into a consistent JSON error format.

Implement pagination and sorting for a collection endpoint.

Apply HTTP method semantics and status codes consistently across CRUD operations.

Implement a layered inventory API with stock-adjustment business rules.

Design relational tables, keys, and relationships from application requirements.

Connect to a local PostgreSQL instance and create tables with suitable data types and constraints.

Insert, update, and delete rows using parameterized SQL statements.

Query rows using filtering, ordering, and pagination.

Combine related tables using inner and outer joins.

Summarize data using aggregate functions and grouping.

Use database transactions to preserve consistency across related writes.

Use EXPLAIN ANALYZE to choose and verify an index for a frequently executed query.

Configure Kotlin support for JPA and map a basic entity and its value fields to a relational table.

Model one-to-many and many-to-one relationships with explicit ownership.

Implement repository operations with Spring Data JPA query methods.

Write a custom repository query for a use case not served by a derived method.

Define transactional boundaries for multi-step service operations.

Version a PostgreSQL schema with Flyway migrations.

Detect and correct an N+1 query problem in a persistence workflow.

Convert the expense analyzer into a persistent Spring Boot REST service.

Define the resource model and API contract for shortened links and redirects.

Generate collision-resistant short identifiers and handle rare collisions.

Implement an HTTP redirect endpoint with the correct response semantics.

Make link-creation requests idempotent for safe client retries.

Implement link-expiration rules and reject expired redirects consistently.

Generate and inspect OpenAPI documentation for a Spring Boot API.

Use structured logs and correlation identifiers to trace a request.

Implement a persistent URL-shortening service with basic visit statistics.

Write isolated service tests with JUnit and test doubles.

Use MockK to verify interactions with a Kotlin dependency.

Test Spring MVC request and response behavior with controller-focused tests.

Test JPA mappings and repository queries against PostgreSQL with Testcontainers.

Write an end-to-end integration test across HTTP, service, and database layers.

Create test fixtures that remain readable and independent.

Use test coverage reports to identify meaningful untested behavior.

Configure a continuous-integration workflow that builds and tests each proposed change.

Distinguish authentication from authorization and session-based security from token-based security.

Store user passwords using an adaptive password-hashing algorithm.

Configure Spring Security to permit public routes and protect private routes.

Generate and sign JSON Web Tokens for authenticated users.

Validate incoming JWT access tokens to authenticate API requests in Spring Security.

Enforce an authorization policy in which administrators can access all issues while ordinary users can access only their own.

Write integration tests for successful and denied security scenarios.

Implement a secured issue-tracking API with user and administrator permissions.

Distinguish blocking work, concurrent work, and parallel work in a JVM backend.

Write suspend functions and launch coroutines within a structured scope.

Call an external HTTP API with a coroutine-compatible Spring client and map its response into an internal model.

Run independent operations concurrently and combine their results safely.

Apply cancellation and timeouts to bound slow operations.

Apply retries with backoff only to operations that are safe to repeat.

Cache a read-heavy result and define an explicit invalidation rule.

Expose health, metric, and diagnostic information for a running Spring Boot service.

Define bounded requirements and design API endpoints and a relational schema for an order-management service.

Implement a complete catalog CRUD vertical slice across controller, service, repository, and database layers.

Implement transactional order-placement rules across service and persistence layers.

Protect capstone operations with authenticated identity and role or ownership checks.

Create a focused automated test suite for the capstone's highest-risk behaviors.

Build a minimal Docker image and run the service with PostgreSQL using Docker Compose.

Deploy the containerized service using environment-based configuration and verify its health.

Present the capstone with API documentation, architecture notes, setup instructions, and demonstrated requests.