Golang

Model customers, resources, and bookings with domain-specific types, half-open time intervals, and an explicit UTC and time-zone policy.

Enforce valid booking-status transitions through methods that preserve domain invariants.

Define typed and wrapped domain errors that callers can classify with errors.Is and errors.As.

Connect services and repositories through narrow consumer-owned interfaces and constructor injection.

Decode JSON requests strictly and reject unknown fields or malformed trailing content.

Validate transport-level request fields separately from booking-domain rules.

Implement and contract-test a create-booking endpoint with an injected application service, including a domain-error response.

Run PostgreSQL with a small Docker Compose configuration and supply connection settings through environment-based configuration.

Design a normalized relational schema for users, resources, availability, and bookings.

Add primary keys, foreign keys, uniqueness constraints, checks, and indexes that enforce booking invariants.

Apply versioned database migrations and safely roll a migration backward.

Configure a pgx connection pool with contexts, limits, and health checks.

Implement parameterized repository operations with pgx while preserving domain error semantics.

Write repository integration tests against an isolated PostgreSQL test database.

Implement interval-overlap detection using the booking domain's half-open boundary rules.

Reproduce a double-booking race by issuing concurrent reservation attempts.

Explain how PostgreSQL isolation levels affect the booking check-then-insert workflow.

Serialize reservations for a single-occupancy resource by locking its row while checking conflicts and inserting within one pgx transaction.

Enforce non-overlapping booking ranges with a PostgreSQL GiST exclusion constraint.

Distinguish retryable serialization and deadlock failures from non-retryable booking conflicts, then apply bounded retry logic.

Verify with a concurrent integration test that only valid reservations commit.

Manage goroutine lifecycles so every background task has an explicit owner and termination path.

Propagate request cancellation and deadlines from HTTP handlers through services to pgx queries.

Build a bounded in-process notification worker pool and identify which accepted work could be lost during a process crash.

Apply backpressure when notification production exceeds processing capacity.

Use the race detector to locate and correct a data race in the service.

Replace direct notification enqueueing by recording an outbox event in the same transaction as its booking.

Claim and process outbox rows safely and idempotently across multiple service instances without losing retryable work.

Write table-driven tests for domain invariants and booking-service behavior.

Create small hand-written fakes for consumer-owned interfaces in service tests.

Fuzz interval construction and overlap logic to discover boundary-case failures.

Write benchmarks that report execution time and allocations for availability searches.

Close the assistant and rebuild the booking repository from a blank file using only documentation for exact APIs.

Close the assistant and reproduce the transaction-based booking operation from a blank file.

Update the implementation scorecard and green, yellow, or red ratings using evidence from independent reproductions.

Validate bearer-token signatures, accepted algorithms, expiration, issuer, and audience before placing trusted identity claims in request context.

Enforce ownership- and role-based authorization in booking operations.

Limit request-body size and reject unsupported media types before decoding input.

Make booking creation safely repeatable by persisting idempotency keys and their completed results.

Implement a concurrency-safe token-bucket rate limiter for selected endpoints.

Emit structured logs with slog using consistent booking, resource, and request attributes.

Prevent secrets and personally identifiable information from entering logs by implementing slog.LogValuer for sensitive domain values.

Propagate a correlation identifier through HTTP, service, database, and background-worker boundaries.

Expose request-rate, error-rate, latency, and worker-queue metrics.

Instrument one booking request path with OpenTelemetry and inspect its HTTP, application, and database spans.

Capture and interpret a CPU profile for a booking-service workload.

Use EXPLAIN ANALYZE to evaluate whether a booking query benefits from its indexes.

Run a repeatable load test and verify that a targeted optimization improves measured behavior.

Before requesting AI-generated code, produce a design and give the AI explicit constraints and acceptance criteria.

Verify AI-generated Go APIs and dependencies against official documentation, compilation, and focused tests.

Review AI-generated database code for transaction boundaries, idempotency, and partial-failure behavior.

Review AI-generated concurrency code with the race detector and a goroutine-lifecycle and channel-ownership checklist.

Ask AI to propose tests, then identify and add edge cases and failure paths it omitted.

Reimplement an AI-assisted component from a blank file and classify the result as green, yellow, or red.

Derive acceptance criteria and failure assumptions from a webhook-delivery brief without requesting a solution.

Design the webhook submission API, PostgreSQL schema, and package boundaries before implementation.

Initialize a blank Go repository and persist accepted webhook-delivery jobs in PostgreSQL.

Implement a bounded worker that claims webhook jobs and sends each request with a deadline.

Classify webhook HTTP outcomes and apply exponential backoff before moving exhausted jobs to a dead-letter state.

Make webhook submission and delivery processing idempotent under duplicate attempts.

Write an integration test verifying that retries and duplicate processing do not create duplicate successful deliveries.

Complete a 45-minute blank-repository implementation of a small backend feature without AI-generated code.

Review an unfamiliar Go service and prioritize findings as critical, important, or nice to have.

Diagnose data races and deadlocks in interview-style Go code snippets.

Identify goroutine leaks and unsafe channel ownership in interview-style Go code snippets.

Diagnose a production-style booking incident from logs, metrics, and traces, then propose a corrective test.

Complete a booking-system design walkthrough covering APIs, schema, concurrency control, failure handling, and scaling trade-offs.

Complete the final 0–5 implementation scorecard using code evidence, compare it with the baseline, and select the next practice targets.