ALD Interview Questionnaire — Level 1

What this evaluates

• Basic software engineering fundamentals
• Ability to read and implement from an existing interface/DTO
• Unit test fluency (Arrange/Act/Assert, edge cases)
• Comfort with refactoring without changing behavior
• Safe AI usage (assist, verify, do not “invent intent”)

What this does not require

• Designing new architecture or interfaces
• Choosing domain boundaries or patterns
• Owning policy decisions
• Deep system design

1) Fundamentals (implementation readiness)

1. You’re given an interface and DTOs. What’s your first step before writing code? (Look for: read tests/specs, identify edge cases, confirm assumptions.)
2. What’s the difference between changing a public interface vs changing an implementation? (Look for: compatibility, downstream impact, contract stability.)
3. Explain “composition over inheritance” in simple terms. When have you used it? (Look for: basic understanding; not required to be deep.)
4. How do you decide what belongs in a method vs extracted into helper functions? (Look for: readability, SRP at a micro level.)

2) Testing (unit tests & reliability)

1. What does a good unit test look like? Walk me through Arrange/Act/Assert.
2. How do you test edge cases without writing brittle tests? (Look for: test behavior, avoid internal details.)
3. What makes tests flaky? How do you prevent flakiness? (Time, randomness, network, shared state.)
4. When is mocking helpful, and when does it cause problems? (Look for: over-mocking, testing implementation vs behavior.)

3) Reading contracts (interfaces/DTOs)

1. If a DTO has a field named ReasonCodes, what does that imply about expected behavior? (Look for: evidence/audit intent, not just error messages.)
2. If an interface method returns a Result object instead of throwing exceptions, how would you implement and test it?
3. What are “invariants” and how do you enforce them in code? (Look for: validation, constructors, avoiding invalid states.)

4) Debugging & refactoring

1. A test started failing after a refactor. What’s your step-by-step approach to diagnose the issue?
2. You find duplicated logic in two classes. How do you refactor safely? (Look for: keep tests passing, small steps, commit frequently.)
3. How do you improve code readability without changing behavior?

5) AI usage (ALD-safe behavior)

1. When using AI to generate code, what do you verify manually before committing? (Look for: tests, edge cases, security, correctness, style.)
2. If AI suggests changing an interface “to make it easier,” what do you do? (Look for: stop, consult, treat as contract change, assess impact.)
3. Describe a good prompt you would use to ask AI for implementation help without changing intended behavior. (Look for: constraints, “do not change contracts,” “make tests pass.”)
4. AI produced code that passes tests but looks suspicious. What now? (Look for: review for correctness, readability, hidden edge cases, add tests.)

6) Mini scenario (discussion-based exercise)

Provide this scenario verbally or as a snippet in the interview:

1. What would you implement first and why?
2. What tests would you add if you suspect an edge case?
3. How would you keep your implementation readable?