Software Engineering

Identify assets, actors, entry points, and trust boundaries in a backend data-flow diagram.

Apply STRIDE to enumerate threats against a backend workflow.

Write an abuse case for an attacker objective relevant to a cybersecurity product.

Rank identified threats with a likelihood-and-impact model.

Convert a high-priority threat into a verifiable security requirement.

Select a preventive, detective, or corrective control for a ranked threat.

Document accepted security risk with an owner, rationale, and review trigger.

Facilitate a time-boxed threat-model review of a proposed service.

Define crate and service boundaries for a Rust backend based on change and trust boundaries.

Choose an asynchronous execution model for an I/O-intensive Rust service.

Implement structured error propagation without exposing sensitive internal details.

Enforce input constraints at a Rust API boundary.

Apply resource limits to untrusted request processing.

Load application secrets through an external secret-provider interface.

Implement graceful shutdown for a stateful Rust service.

Verify the dependency inventory and provenance of a Rust service artifact.

Select an authentication flow for a human, machine, or device identity.

Validate the security-relevant claims of an access token.

Model backend permissions with role-based access control.

Model context-sensitive backend permissions with attribute-based access control.

Specify tenant-aware authorization checks at an API boundary.

Establish workload identity between services using mutually authenticated channels.

Design a signing-key rotation procedure that preserves service availability.

Model a privileged administrative workflow with step-up authentication and auditability.

Classify stored data by sensitivity and retention obligations.

Select a PostgreSQL tenant-isolation pattern for a stated threat model.

Choose a transaction isolation level for a security-sensitive workflow.

Design an encryption-at-rest scheme with separated key-management responsibilities.

Design field-level protection for a high-sensitivity database attribute.

Construct a tamper-evident audit-log chain.

Plan an online schema migration that preserves backward compatibility.

Define a restore test that verifies recovery point and recovery time objectives.

Choose a consistency model from explicit business invariants.

Design an idempotency mechanism for a retried command.

Set timeout and retry budgets for a multi-service request path.

Select a conflict-resolution strategy for concurrently updated state.

Apply the transactional outbox pattern to database-backed event publication.

Model a compensating transaction for a failed multi-step workflow.

Choose a cache consistency strategy for security-sensitive data.

Specify overload controls using admission limits, backpressure, and load shedding.

Derive an event schema from a representative security-telemetry source.

Choose a partition key for an ordered, horizontally scaled event stream.

Specify delivery semantics for a security-event consumer.

Design event deduplication within a bounded processing window.

Plan backward-compatible evolution of an event schema.

Apply backpressure across ingestion, buffering, and persistence stages.

Separate hot, warm, and cold storage according to query and retention needs.

Select an indexing strategy for time-bounded behavior searches.

Frame a behavior-detection problem as supervised, unsupervised, or semi-supervised learning.

Create a temporally valid training and evaluation split for event data.

Transform categorical and cyclical behavior attributes into numerical features.

Calculate a logistic-regression prediction from model weights and an entity feature vector.

Implement logistic-regression training with gradient descent in Python.

Diagnose underfitting and overfitting from training and validation curves.

Compute precision, recall, false-positive rate, and PR-AUC for an imbalanced detector.

Select a decision threshold from the relative costs of missed and false alerts.

Implement a rolling z-score baseline for per-entity behavior.

Compute a multivariate anomaly score with Mahalanobis distance.

Implement k-means clustering for peer-group discovery.

Calculate an isolation-tree anomaly score for a behavior record.

Estimate a first-order Markov model of entity activity transitions.

Train a small autoencoder to reconstruct normal behavior vectors.

Construct an interaction graph for entity-behavior analysis.

Select a behavioral model from label availability, latency, and explainability constraints.

Design a batch or streaming inference path from detection-latency requirements.

Detect feature-distribution drift against a production baseline.

Explain an anomalous score using feature-level contributions.

Design an analyst-feedback loop that limits confirmation bias.

Threat-model model poisoning, evasion, and inference abuse.

Design a retrieval-grounded AI assistant for summarizing behavior investigations.

Specify guardrails against prompt injection and sensitive-data disclosure.

Define rollout and rollback criteria for a new behavioral model version.

Choose a tenant-isolation model from security, scale, and cost requirements.

Separate control-plane and data-plane responsibilities for a cybersecurity platform.

Design network trust zones for internet-facing and internal services.

Map a cloud-neutral component design to representative managed-cloud services.

Define a service-level objective for a critical detection journey.

Design diagnostic telemetry for a stated platform failure mode.

Design a multi-region recovery sequence for a stateful backend.

Define an architecture fitness function for a critical system constraint.

Write an architecture brief for a multi-tenant behavioral-threat-detection platform.

Produce a capacity model for the platform under normal and attack traffic.

Produce a threat model for the platform's highest-risk data path.

Specify the platform's event, feature, and inference contracts.

Train and evaluate one behavioral model on representative event data.

Integrate the selected model into a minimal Rust-backed scoring path.

Defend the capstone architecture under a structured design-review challenge.

Create a principal-level interview portfolio that links architecture decisions to measurable outcomes.