Applied Machine Learning Engineering

Derive bounded contexts and a ubiquitous language from business requirements.

Distinguish entities from value objects using identity and lifecycle rules.

Define an aggregate boundary that protects stated domain invariants.

Implement an aggregate state transition that enforces an invariant and records a domain event.

Define use-case and repository ports that keep the domain independent of frameworks and persistence.

Coordinate a use case through an application service without leaking transport or database concerns.

Implement Spring Boot transport and persistence adapters that map external models without contaminating the domain.

Enforce dependency direction between domain, application, and adapter layers with an architecture test.

Specify a versioned REST contract with pagination, idempotency, and stable error responses.

Create a STRIDE threat model for a backend request path and prioritize its highest-risk threats.

Trace an OAuth 2.0 authorization-code flow with OpenID Connect.

Validate signed access tokens while supporting issuer key rotation.

Choose and enforce role-based or attribute-based object-level authorization for a stated access rule.

Validate and canonicalize API inputs to prevent injection and path-traversal vulnerabilities.

Design an append-only, tamper-evident audit record for a privileged operation.

Store application secrets outside source code and rotate a compromised credential.

Design a normalized relational schema that enforces stated domain invariants.

Diagnose a slow SQL query using its execution plan and add an appropriate index.

Choose a transaction isolation level for a stated consistency requirement.

Prevent lost updates by applying optimistic locking to a database write.

Implement keyset pagination for a large ordered result set.

Apply cache-aside caching to a frequently accessed read path.

Define an invalidation policy that bounds stale-data risk after a write.

Plan a backward-compatible database migration with an explicit rollback path.

Decide whether a bounded context should remain in a modular monolith or become a separate service.

Assign data ownership to services without permitting direct cross-service database access.

Choose synchronous or asynchronous communication for a stated service interaction.

Route external traffic through an API gateway without coupling it to domain logic.

Use service discovery to address changing service instances.

Configure timeouts, retry limits, and jitter for a remote call.

Prevent cascading failures using circuit breakers and bulkheads.

Detect breaking service changes with consumer-driven contract tests.

Define a versioned event schema that remains compatible with existing consumers.

Choose a partition key that balances load while preserving required event order.

Implement an idempotent consumer for at-least-once message delivery.

Use the transactional outbox pattern to prevent lost database events.

Relay outbox records through change data capture without introducing dual writes.

Model a distributed business workflow as a saga with compensating actions.

Separate write commands from a denormalized read model using CQRS.

Recover a failed projection by replaying events from a known checkpoint.

Estimate service capacity from traffic, payload, latency, and storage assumptions.

Relate concurrency, throughput, and response time using a simple queueing calculation.

Define service-level indicators, a service-level objective, and its error budget.

Instrument a request path with structured logs, metrics, and distributed traces.

Use a load test to identify the first saturated system resource.

Protect a saturated dependency using bounded queues and load shedding.

Design health checks and failover behavior for a replicated service.

Diagnose an incident from telemetry and write a blameless corrective action.

Build a minimal non-root container image for a Spring Boot service.

Deploy a stateless service using Kubernetes Deployment and Service resources.

Inject environment-specific configuration through ConfigMaps and externally supplied Secrets.

Configure startup, readiness, and liveness probes for distinct failure conditions.

Set CPU and memory requests and limits from measured resource usage.

Configure horizontal autoscaling from a stated utilization target.

Expose a service through an ingress with TLS termination.

Execute a rolling or canary deployment with automated health checks and rollback.

Create architecture and sequence diagrams for a high-volume order platform from supplied requirements and SLOs.

Implement and test a retry-safe order-command vertical slice using an aggregate, application service, and hexagonal adapters.

Implement one successful path and one compensation path for an order saga using the supplied messaging infrastructure.

Build a CQRS order-status view backed by a cacheable read model.

Enforce OAuth 2.0 token authentication and role-based authorization on user and administrative endpoints.

Implement an auditing interceptor that generates tamper-evident records for administrative actions.

Deploy the project stack to a local Kubernetes cluster from provided base manifests and verify its health probes.

Run a load test against the deployed platform, identify one bottleneck, and validate a targeted improvement.

Represent tabular data as vectors and matrices and compute a linear prediction.

Compute the gradient of mean squared error and perform a gradient-descent update.

Compute conditional probabilities using Bayes' rule.

Calculate and interpret mean, variance, and covariance for model features.

Translate a product question into a prediction target, evaluation metric, and leakage-safe data split.

Build a scikit-learn preprocessing pipeline for numerical and categorical features.

Compare logistic regression, decision trees, and gradient boosting under one validation protocol.

Perform slice-based error analysis and justify a final model choice.

Train a small PyTorch multilayer perceptron on the earlier tabular task and compare it with the selected classical model.

Generate and normalize text embeddings using a pretrained transformer.

Build a content-based recommender using vector similarity.

Chunk source documents while preserving metadata required for citations.

Create a vector index and retrieve relevant passages for a query.

Connect a retriever and language model into a citation-producing RAG service.

Evaluate a RAG test set using retrieval hit rate and a rubric for grounded, citation-supported answers.

Test RAG resilience against direct and indirect prompt-injection attacks using adversarial cases.

Make an ML training run reproducible using versioned data, configuration, and experiment tracking.

Deploy a validated FastAPI inference endpoint as a Docker container.

Connect a Spring Boot gateway to a versioned Python inference API.

Publish user-feedback events for later model evaluation and retraining.

Create a CI check that detects preprocessing or inference-contract regressions.

Define monitoring and rollback triggers for latency, errors, input drift, and delayed model quality.

Write quantified, role-specific résumé bullets for the backend and ML projects.

Deliver an interview-style walkthrough defending the projects' architecture, security, scalability, and ML trade-offs.