Go Programming

Model domain data with structs, composition, and field tags.

Define methods with appropriate pointer or value receivers.

Design narrow interfaces that are satisfied implicitly at the point of use.

Use type assertions and type switches safely when working with interface values.

Implement reusable type-safe functions with generics and constraints.

Encode and decode JSON while controlling optional, omitted, and custom fields.

Write table-driven unit tests with subtests and clear failure diagnostics.

Create test doubles by substituting dependencies through narrow interfaces.

Start goroutines with explicit ownership and termination conditions.

Use unbuffered and buffered channels with a clear channel-closing responsibility.

Coordinate multiple channel operations with select.

Propagate deadlines and cancellation through call chains with context.Context.

Protect shared state by choosing appropriately between mutexes and atomic operations.

Implement a bounded worker pool that collects results and errors.

Cancel related concurrent tasks when the first task fails.

Detect and correct a data race with Go's race detector.

Register method-aware routes and implement HTTP handlers with net/http.

Compose middleware for cross-cutting HTTP request behavior.

Decode and validate request payloads while returning consistent client errors.

Encode typed API responses and centralized error responses.

Separate HTTP, service, and repository responsibilities with explicit dependencies.

Implement pagination, filtering, and sorting for a collection endpoint.

Configure server timeouts and perform graceful shutdown.

Describe and validate the API contract with an OpenAPI specification.

Design a normalized PostgreSQL schema for the course API's core entities.

Apply forward and rollback schema changes with versioned migrations.

Execute parameterized queries and scan results using a context-aware connection pool.

Use database transactions to preserve a multi-step business invariant.

Interpret an EXPLAIN plan and add an index for a demonstrated query bottleneck.

Store and verify user passwords using an appropriate password-hashing algorithm.

Implement token-based authentication for protected API endpoints.

Enforce role- or ownership-based authorization independently of authentication.

Test HTTP handlers and middleware with net/http/httptest.

Run repeatable repository integration tests against an isolated PostgreSQL instance.

Add fuzz tests for an input parser or request boundary.

Emit structured, request-correlated logs with log/slog.

Expose service metrics suitable for Prometheus collection.

Trace an HTTP-to-database request path with OpenTelemetry.

Write a Go benchmark and compare time and allocation results.

Use pprof evidence to identify a CPU or memory hotspot.

Enforce end-to-end latency budgets with propagated timeouts.

Retry only safe transient failures using exponential backoff and jitter.

Make a state-changing API operation idempotent with an idempotency key.

Prevent repeated downstream failures with a circuit breaker.

Protect an endpoint with a token-bucket rate limiter.

Add cache-aside reads while defining expiration and invalidation behavior.

Publish and consume a background job through Amazon SQS.

Handle duplicate message delivery without duplicating business effects.

Build a minimal non-root container image with a multi-stage Dockerfile.

Run the API and its dependencies locally with Docker Compose.

Explain how VPC subnets, security groups, and routing isolate an AWS workload.

Apply least-privilege permissions to a workload with an IAM role.

Push versioned container images to Amazon ECR.

Deploy the API as an Amazon ECS Fargate service behind an Application Load Balancer.

Connect the service securely to Amazon RDS and AWS Secrets Manager.

Configure CloudWatch logs, service metrics, and an actionable alarm.

Explain Terraform's configuration, state, plan, and apply lifecycle.

Parameterize infrastructure with typed variables, local values, and outputs.

Create a reusable Terraform module with a narrow resource interface.

Store Terraform state remotely with locking and encryption.

Import or reconcile an existing AWS resource without recreating it.

Validate and plan Terraform changes in a pull-request workflow.

Build, test, and publish the Go service with a CI pipeline.

Deploy a new service version with an automated rollback condition.

Model the API as Kubernetes Deployment and Service resources.

Expose HTTP traffic through an Ingress and its AWS load balancer integration.

Supply runtime configuration through ConfigMaps and Secrets.

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

Set resource requests and limits from observed workload behavior.

Scale replicas with a HorizontalPodAutoscaler.

Package and parameterize the application with Helm.

Diagnose a failed EKS deployment using events, logs, and workload status.

Analyze the time and space complexity of a Go solution.

Use a hash map or set to eliminate repeated lookup work.

Solve an ordered-sequence problem with two pointers.

Solve a contiguous-range problem with a sliding window.

Use stacks and queues to solve traversal or matching problems.

Reverse or restructure a linked list without losing nodes.

Apply binary search to a monotonic search space.

Use a heap to maintain the top k elements of a stream.

Traverse a binary tree iteratively and recursively.

Search a graph with breadth-first or depth-first search while preventing revisits.

Merge and schedule overlapping intervals.

Solve a recurrence with memoization and bottom-up dynamic programming.

Diagnose Go interview snippets involving slices, interfaces, defer, and nil values.

Explain how goroutine scheduling and garbage collection affect service behavior.

Produce capacity estimates, an API contract, and a data model from a system-design prompt.

Design an AWS-hosted backend that addresses scaling, caching, asynchronous work, observability, and failure recovery.