Shopify·Machine Learning Engineer·Take-home Assignment·Senior

SeniorPrefer not to say

Jul 2026Remote

Summary

Take-home assignment for a Machine Learning Engineer role at Shopify. The task was to build a fully functional word-guessing game from scratch, which felt a bit unexpected for an ML position but whatever, you do what they ask.

Questions Asked (1)

Design and implement a standalone word-guessing game that selects a random secret word from a dictionary file, accepts fixed-length alphabetic guesses via command line, returns per-letter positional feedback after each guess, enforces a maximum attempt limit, reports win/lose outcomes, persists game statistics locally, includes unit tests, and comes with build/run instructions and a writeup of your key design decisions.

System DesignTechnical Trade-offsAlgorithms & Data Structures

Author's notes

This was a lot.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then outline a modular design that separates concerns (word selection, guess validation, feedback generation, game state, persistence, and CLI). Walk through the implementation choices, emphasizing testability and extensibility, and conclude with how you would validate the solution with unit tests and document design decisions.

Pro tip: Demonstrate production mindset by discussing how you'd handle edge cases (e.g., dictionary loading failures, invalid inputs) and how the design could evolve into a service or support different feedback mechanisms (like Wordle's color coding).

1. Clarify Requirements and Constraints

Ask questions to understand the expected dictionary size, word length, guess format, attempt limit, and persistence mechanism. Confirm whether the game is single-player and if statistics should be per-user or global.

2. Design the Architecture

Propose a modular design with clear interfaces: a WordProvider for random selection, a GuessValidator, a FeedbackGenerator, a GameState manager, a StatsRepository for persistence, and a CLI handler. Discuss trade-offs between simplicity and extensibility.

3. Implement Core Logic

Detail the algorithm for feedback generation (e.g., exact match, present but wrong position, absent) and how to handle duplicate letters. Explain how to enforce attempt limits and track game state.

4. Add Persistence and CLI

Describe how statistics (games played, wins, losses, guess distribution) will be stored locally (e.g., JSON file) and updated atomically. Outline the command-line interface for starting a game and making guesses.

5. Testing and Documentation

Outline unit tests for each component, including edge cases (empty dictionary, invalid guesses, duplicate letters). Mention build/run instructions and a design writeup covering key decisions and trade-offs.

Key Points to Mention

Modular design with separation of concerns (e.g., word selection, feedback logic, persistence) to enhance testability and maintainability.
Algorithm for per-letter feedback, including handling of duplicate letters (e.g., using a two-pass approach or frequency counting).
Input validation and error handling for command-line guesses (e.g., length, alphabetic characters, case insensitivity).
Persistence strategy: local file storage (JSON, SQLite) with considerations for concurrent access and data integrity.
Unit testing approach: mocking dependencies, testing edge cases, and achieving high coverage.
Design trade-offs: simplicity vs. extensibility, performance for large dictionaries, and potential for future enhancements (e.g., multiplayer, different feedback styles).

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