Asana Software Engineer Interview Questions
7+ questions from real Asana Software Engineer interviews, reported by candidates.
Round Types
Top Topics
Questions
I found a lot of helpful posts on the forum when I was preparing for the interview, so I'm posting this to give feedback. I haven't received the results yet. I applied for a Team Leader (TL) position,
Asana Fulltime SDE Tech Phone Screen Experience and Interview Overview
First Round of Challenges: Off Camera Zoom Questions 1/2: * You are shown two code snippets on the coding panel without writing any code, and asked what they do. Also, the time and space complexity of
Asana Virtual Onsite Interview for SWE
Hey everyone! I’ve got my remote onsite interview with Asana coming up soon. From what I’ve heard, it includes three parts: a Code Review round, DSA + LLD, and a System Design (HLD) round. I’ve been b
LeetCode #973: K Closest Points to Origin. Difficulty: Medium. Topics: Array, Math, Divide and Conquer, Geometry, Sorting, Heap (Priority Queue), Quickselect. Asked at Asana in the last 6 months.
LeetCode #238: Product of Array Except Self. Difficulty: Medium. Topics: Array, Prefix Sum. Asked at Asana in the last 6 months.
## Round 1 - Coding / OOD ## Problem Design an ASCII art rendering system. Support rendering rectangles, triangles, and text banners to a 2D character canvas. Each shape is a separate class. The canvas can combine multiple shapes and print the result. ```python class Canvas: def __init__(self, width: int, height: int, fill: str = " "): ... def draw(self, shape: 'Shape', x: int, y: int) -> None: ... def render(self) -> str: ... class Rectangle: def __init__(self, width: int, height: int, char: str = "*"): def pixels(self) -> list[tuple[int,int]]: ... class TextBanner: def __init__(self, text: str): def pixels(self) -> list[tuple[int,int,str]]: ... ``` ## Example ``` c = Canvas(10, 5) c.draw(Rectangle(4, 3, "#"), x=1, y=1) c.render() # ---------- # | | # | #### | # | #### | # | #### | # ---------- ``` ## Follow-ups 1. How do you handle overlapping shapes — which one takes priority and why? 2. How would you add a `Triangle` shape that fills using Bresenham's line algorithm? 3. How would you support layering (z-index) so shapes can be explicitly ordered? 4. How would you serialize the canvas state to a JSON file and restore it?
## Round 1 - Coding / OOD ## Problem Simulate a turn-based grid game where cats try to catch rabbits. Each turn: rabbits move randomly to an adjacent cell; cats move one step toward the nearest rabbit. If a cat and rabbit occupy the same cell, the rabbit is caught. Simulate until all rabbits are caught or a max turn limit is reached. ```python class Animal: def __init__(self, animal_id: str, x: int, y: int): ... def move(self, dx: int, dy: int): ... class Cat(Animal): def choose_move(self, rabbits: list['Rabbit']) -> tuple[int,int]: ... class Rabbit(Animal): def choose_move(self) -> tuple[int,int]: ... class Game: def __init__(self, grid_size: int, cats: list[Cat], rabbits: list[Rabbit]): ... def step(self) -> list[str]: # returns ids of caught rabbits this turn ... def run(self, max_turns: int) -> dict: # returns {"turns": int, "caught": list[str], "escaped": list[str]} ... ``` ## Example ``` cats = [Cat("C1", 0, 0)] rabbits = [Rabbit("R1", 4, 4)] game = Game(grid_size=5, cats=cats, rabbits=rabbits) game.run(max_turns=20) # -> {"turns": 8, "caught": ["R1"], "escaped": []} ``` ## Follow-ups 1. How does your cat movement strategy change if there are multiple rabbits — does the cat chase the nearest or apply some heuristic? 2. How do you prevent two cats from targeting the same rabbit inefficiently? 3. What happens on a toroidal grid (edges wrap around)? 4. How would you add a line-of-sight constraint so cats can only move toward rabbits they can "see"?
What Asana Looks for in Software Engineer Interviews
Asana Software Engineer interviews are calibrated against the level and scope expected of the role. Across 7+ verified candidate reports on LeakCode, the consistent signals interviewers look for: clear problem decomposition before coding, explicit complexity reasoning, structured handling of edge cases, and the ability to articulate trade-offs between two reasonable approaches.
The discriminator between candidates who advance and candidates who do not is rarely the final correctness of the solution. It is the path to the solution: did you ask clarifying questions, did you state your approach before coding, did you handle edge cases without prompting, and did you communicate your reasoning throughout. Reports tagged "no hire" frequently cite a working solution with poor communication; reports tagged "strong hire" cite clear thinking even when the final solution was incomplete.
How To Use This Question Set
Real interview reports are a calibration tool, not a memorization target. Companies update their question pools every 2-4 months; memorizing exact problems risks misleading you when the interviewer uses a variant. The high-leverage use: identify the patterns that appear repeatedly in Asana Software Engineer reports, practice those patterns on similar (not identical) problems, and use the reports to understand the interviewer's typical follow-up depth.
Filter the questions below by round type, difficulty, and recency. Focus first on reports from the past 6-12 months; older reports may reference questions that have since rotated out of Asana's pool. Reports tagged with quantified difficulty (e.g., "medium-hard") are higher-signal than reports without difficulty tags.
Round-by-Round Expectations
Asana Software Engineer loops typically span 4-6 rounds across phone screens and on-site or virtual on-site interviews. The structure varies by company: some run 1 recruiter screen + 1 technical phone + 3-4 on-site rounds; others run 1 recruiter screen + 1 OA + 4-5 on-site rounds. The recruiter screen is logistics and culture-light; the technical phone screen is medium-difficulty coding; the on-site loop covers coding, system design (at L4+ levels), and behavioral rounds.
Each round is designed to surface a specific signal. Coding rounds: correctness, code quality, complexity reasoning, communication. System design rounds: requirements clarification, design judgment, operational thinking. Behavioral rounds: ownership scope, leadership, ambiguity tolerance, conflict navigation. Strong candidates explicitly hit each signal dimension out loud during the round; weak candidates focus only on solving the prompt.
Common Interview Mistakes At This Combination
Reports tagged "no hire" at Asana Software Engineer commonly cite: jumping into code without clarifying requirements, coding silently for 10+ minutes without verbalizing approach, missing edge cases (empty input, single element, very large input, overflow), and producing a working solution that the candidate cannot explain or refactor when probed. Strong candidates avoid these patterns by following a consistent template: clarify, verbalize approach, code with narration, test with examples.
Behavioral and design rounds have their own failure modes. Behavioral: stories that use "we" instead of "I" diluting individual signal, stories with no quantified outcome, defensiveness when probed about failure. Design: not asking clarifying questions, not stating requirements out loud, designing for a single server when the prompt clearly implies scale, ignoring operational concerns (deployment, monitoring, rollback). These show up in roughly half of Asana Software Engineer interview retrospectives on LeakCode.
See All 7 Asana Software Engineer Questions
Full question text, answer context, and frequency data for subscribers.
Get Access