Coding Implementation and Quality Questions

Assesses the ability to implement robust, readable, and maintainable code during interviews and in production. Topics include writing syntactically correct solutions, thorough handling of edge cases and invalid inputs, null checks and boundary conditions, clean naming and function design, design patterns and avoiding antipatterns, unit testability, debugging and tracing techniques, and adapting solutions in real time when interviewers introduce follow up constraints or optimization requests. Candidates should demonstrate both correctness and production orientation in their code.

MediumTechnical

39 practiced

Design a pragmatic code-review checklist for a backend service team focused on correctness, readability, testing, and deploy safety. Provide at least 10 checklist items and explain which three you'd consider mandatory for merging to main.

EasyTechnical

29 practiced

Explain three ways to improve testability of code written with heavy static dependencies (global state, singletons, direct DB calls). For each way, provide a short code or design example and discuss trade-offs.

Sample Answer

**Brief framing (manager view)**

As an engineering manager I focus on team practices that make code easier to test, reduce flakiness, and speed up feedback. Here are three practical approaches, examples, and trade-offs.

**1) Introduce dependency injection (constructor/inversion of control)**

- Idea: Pass dependencies rather than access globals.- Example:

python

# Python
class UserService:
    def __init__(self, db):
        self.db = db
    def get_user(self, id):
        return self.db.query_user(id)

- Trade-offs: Requires refactoring and discipline; increases testability and clarity. Slight initial effort; good long-term ROI.

**2) Add abstraction seams / interfaces for external systems**

- Idea: Wrap singletons/direct DB calls behind interfaces so tests replace them.- Example:

java

interface EmailSender { void send(Event e); }
class SmtpEmailSender implements EmailSender { ... }
class MockEmailSender implements EmailSender { ... }

- Trade-offs: More classes and indirection; improves mocking, allows contract testing.

**3) Use test doubles and environment config (seams via factories/DI container)**

- Idea: Provide factories or environment-based wiring so CI injects in-memory DBs or fakes.- Example:

// wiring
if (process.env.TEST) db = new InMemoryDB(); else db = new PostgresDB();

- Trade-offs: Risk of divergence between test and prod behavior; mitigate with integration tests and shared contracts.

As manager, enforce patterns via code reviews, templates, and CI checks to ensure teams adopt these consistently.

HardTechnical

26 practiced

Given a production service suffering from a memory leak, outline the end-to-end technical approach you would lead: tooling to identify leaks, code-level fixes, testing to prevent regressions, and deployment strategy for a safe fix.

MediumTechnical

27 practiced

You need to introduce a linter and formatter into a large repo with many active branches and some legacy code. Describe a rollout plan that minimizes merge conflicts, keeps developers productive, and enforces consistent style over time.

HardTechnical

27 practiced

Create a migration plan to move a heavily coupled monolith module to a new library used by multiple services. Include steps for API design, backward-compatibility, tests, gradual cutover, and metrics to validate success.

Sample Answer

**Overview & goal**Move a tightly coupled monolith module into a shared library used by multiple services with zero or minimal customer-visible disruption. Outcome: reduced duplication, easier maintenance, safe rollout.

**High-level plan (phases)**1. Discovery & constraints (1–2 sprints) - Inventory API surface, call sites, data contracts, side effects, performance hotspots. - Identify owners, SLAs, and compatibility requirements.

2. API design & contracts - Define a stable public API: clear inputs/outputs, errors, idempotency, auth. - Publish OpenAPI/IDL + semantic versioning rules (MAJOR.MINOR.PATCH). - Design for feature toggles and configurable behavior.

3. Implementation & tests (2–4 sprints) - Build library alongside monolith (adapter layer inside monolith calling library). - Tests: unit, integration, contract tests, property tests for edge cases. - Create consumer-driven contract tests (e.g., Pact) that run in CI for each service.

4. Backward-compatibility strategy - Support v1 API in library; add non-breaking enhancements behind flags. - Maintain adapter in monolith while consumers migrate. - Use feature flags and compatibility shims; document deprecation timelines.

5. Gradual cutover & rollout - Canary: route small % of requests from one service instance to library implementation. - Shadowing: mirror production calls to library to validate behavior without affecting users. - Incremental: migrate services one-by-one, using CI contract checks + canary per service. - Full switch and remove adapter after all consumers on stable version and one deprecation cycle.

6. Observability & metrics to validate success - Functional correctness: error rate, business metric parity, success ratio compared to baseline. - Latency & resource: p95/p99 latency, CPU/memory, tail latencies. - Usage: number of services on new library, library adoption rate. - Contract health: CI pass rate for consumer-provider contracts. - Rollback triggers: error delta > X%, increased latency > Y ms, contract failures.

**Team & governance**- Appoint library owner team, migration champions in each consumer team.- Weekly migration sync, public migration dashboard, defined SLA for support.

**Risks & mitigations**- Behavioral mismatches → contract tests + shadowing.- Performance regressions → profiling, optimize hotspots, fallbacks.- Coordination delays → migration roadmap, deadlines, and automated checks.

This plan balances technical safety, clear ownership, measurable outcomes, and predictable cutover for minimal disruption.

Unlock Full Question Bank

Get access to hundreds of Coding Implementation and Quality interview questions and detailed answers.

Join thousands of developers preparing for their dream job.