AkunaCapital·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

May 2026

Summary

Akuna Capital software engineer interview with a design-focused coding round. The question started simple enough but had a follow-up that really tested whether you knew your patterns.

Questions Asked (1)

Design an Enemy factory for a multiplayer game that returns an enemy instance of a given color. Start with the basic factory and class hierarchy, then redesign it to handle massive memory usage when thousands of enemies are spawned.

System DesignTechnical Trade-offsAlgorithms & Data Structures

Author's notes

The first part was fine, factory method, base Enemy class, color property, nothing crazy.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by outlining a simple factory method pattern with a base Enemy class and subclasses for each color, then identify the memory overhead from thousands of instances. Redesign using the Flyweight pattern to share intrinsic state (color, sprite, stats) across enemies, storing only extrinsic state (position, health) per instance, and discuss trade-offs like increased complexity and potential performance gains.

Pro tip: Emphasize that the Flyweight pattern is ideal when many objects share common state, but also mention that you'd measure memory usage before and after to validate the optimization, showing a data-driven approach.

1. Clarify requirements and constraints

Ask about the expected number of enemies, memory limits, and whether enemies of the same color share behavior/stats. Confirm if enemies are mutable and if color is the only varying attribute.

2. Design basic factory and class hierarchy

Propose an Enemy interface or abstract class with concrete subclasses like RedEnemy, BlueEnemy, etc. Implement a simple factory that returns a new instance based on color.

3. Identify memory issues

Explain that creating thousands of separate instances duplicates common data (e.g., color, sprite, stats), leading to high memory usage and GC pressure.

4. Redesign with Flyweight pattern

Introduce a Flyweight factory that caches and reuses shared enemy objects (intrinsic state). Separate extrinsic state (position, health) into a context object or store it externally.

5. Discuss trade-offs and alternatives

Compare Flyweight with other patterns like Object Pool or Prototype. Mention trade-offs: memory savings vs. complexity, potential concurrency issues, and the need to manage extrinsic state carefully.

Key Points to Mention

Factory Method pattern for basic creation
Flyweight pattern to share intrinsic state (color, sprite, stats)
Separation of intrinsic and extrinsic state
Memory profiling and measurement to validate optimization
Thread safety in a multiplayer context (e.g., concurrent access to flyweight cache)
Alternative patterns like Object Pool or Prototype and when to use them

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.