Canva Data Engineer Interview Guide

Most candidates prep for Canva's Data Engineer interview like they're interviewing at a mid-size SaaS company. Then they discover the platform processes billions of events daily, the data team owns a semantic layer that gates product decisions, and the engineering bar looks more like a backend software role than a traditional DE shop. That mismatch is where most people lose ground before they even start.

Canva Data Engineer Role

Your job is to own the data platform layer that keeps Canva's product and growth teams honest. That means building ELT flows in dbt and Snowflake, maintaining Fivetran connectors that pull from systems like Affinity CRM, and curating mart models that analysts query directly through Looker and Mode. After a year, success looks like this: downstream teams trust your models enough to ship experiments and dashboards without pinging you to verify numbers.

A Typical Week

The widget tells the time-split story, but what it won't convey is how interleaved the work feels. A Monday morning SLA review can cascade into an unplanned Fivetran connector fix that eats your afternoon, which means the dbt model you planned for Tuesday slips to Wednesday. On-call weeks compress everything further, and the Friday #data-help rotation (fielding analyst questions about stale Looker explores or wrong dbt model references) is a real time sink that doesn't show up neatly in any single category.

Projects & Impact Areas

The event ingestion infrastructure is the foundation, but the work that shapes your reputation sits above it: building dbt mart models that join raw event streams with subscription state for products like Canva Teams, then defending those models' freshness and correctness under SLA. You'll also spend real cycles on migration work (the Redshift-to-Snowflake cutover involves parallel validation, row-count diffing, and writing runbooks that future engineers can actually follow) and cross-system data unification as Canva connects new data sources and reconciles schemas across them.

Skills & What's Expected

Canva's software engineering expectations are what separate this role from most DE jobs. Clean Python, proper test coverage, CI/CD fluency, and code review rigor that would pass on a backend team are all table stakes here, not nice-to-haves. ML and GenAI show up as a small interview topic area, so they're worth a light pass but shouldn't consume your prep time. The underrated skill is communication: you'll present pipeline health and data quality findings to product stakeholders, not just build in silence, and the interview process reflects that expectation.

Levels & Career Growth

The widget shows the full L2-through-L6 band structure. What it doesn't capture is the nature of the L4-to-L5 transition: Canva's promo criteria at Staff require leading multi-quarter, org-level initiatives (think standardizing data contracts across squads or driving a platform migration that measurably improves reliability for teams beyond your own). Canva's engineering culture rewards exploration, with public blog posts about experimenting with new programming languages, so proposing and owning a technical migration can be a legitimate growth lever if you frame it as org-wide impact.

Work Culture

Sydney's Surry Hills HQ runs hybrid with most data engineers in-office Tuesday through Thursday, and free catered lunch sweetens the deal. Engineers are genuinely offline by 6 PM most days, with weekend work culturally discouraged (though on-call weeks are the exception). The "be a force for good" value surfaces in day-to-day priorities around documentation and data discoverability, not just shipping speed.

Canva Data Engineer Compensation

Canva is still private, so your equity grant can't be sold on the open market until an IPO or secondary sale. RSUs vest over multiple years, but the illiquidity means you should pressure-test what that stock is actually worth to you today. Before accepting, ask your recruiter to confirm whether refresh grants exist and how they're sized, because the initial offer letter won't always spell that out.

The single biggest lever in a Canva negotiation is getting your level right before discussing dollars. If you can make a credible case for a higher band (say, L4 instead of L3), every other number shifts upward automatically. Once level is locked, a competing offer from a public company is your strongest tool for pushing base salary or a signing bonus that compensates for equity you can't yet liquidate.

Canva Data Engineer Interview Process

The widget above covers the round-by-round flow. What it won't tell you is that Canva's hiring manager screen functions more like a lightweight system design round than the "tell me about yourself" chat you've had elsewhere. Canva's HMs (internally called "coaches") will probe architecture thinking: batch-vs-streaming tradeoffs for their 25B daily event pipeline, idempotency strategies, partitioning decisions for their experimentation platform. Candidates who treat round two as a culture chat get filtered before they ever reach the technical assessments.

The most common rejection pattern, from what candidates report, is weak coding fundamentals paired with shallow reliability thinking. Canva's coding round mirrors what their software engineers face, so you'll write live solutions in your primary language (Python, Java, or Go) and defend complexity tradeoffs under time pressure. If your prep has been purely SQL and dbt, that round will hurt. But even candidates who clear coding stumble when they can't articulate how they've handled SLAs, backfills, or postmortems on production pipelines. No single strong round rescues a weak one here, so treat every stage as load-bearing.

Canva Data Engineer Interview Questions

1/*
2Assumptions:
3- Table: analytics.design_events_raw
4- Columns:
5  - event_id (string)
6  - design_id (string)
7  - event_name (string) values include 'design_published'
8  - event_time_utc (timestamp_ntz)
9  - ingested_at (timestamp_ntz) ingestion time, later means newer copy
10*/
11
12WITH deduped AS (
13  SELECT
14    event_id,
15    design_id,
16    event_time_utc,
17    ingested_at
18  FROM analytics.design_events_raw
19  WHERE event_name = 'design_published'
20  QUALIFY ROW_NUMBER() OVER (
21    PARTITION BY event_id
22    ORDER BY ingested_at DESC
23  ) = 1
24)
25SELECT
26  CAST(event_time_utc AS DATE) AS event_date_utc,
27  COUNT(DISTINCT design_id) AS designs_published
28FROM deduped
29GROUP BY 1
30ORDER BY 1;

1/*
2Goal: Flag (user_id, day) where > 5% of sessions overlap for that user.
3Overlap definition: a session starts before the previous session ends, after ordering by start_time.
4
5Assumptions:
6- Table: analytics.editor_sessions
7- Columns:
8  - user_id (string)
9  - session_id (string)
10  - session_start_utc (timestamp_ntz)
11  - session_end_utc (timestamp_ntz)
12*/
13
14WITH sessions_by_day AS (
15  SELECT
16    user_id,
17    session_id,
18    CAST(session_start_utc AS DATE) AS session_date_utc,
19    session_start_utc,
20    session_end_utc
21  FROM analytics.editor_sessions
22  WHERE session_start_utc IS NOT NULL
23    AND session_end_utc IS NOT NULL
24    AND session_end_utc >= session_start_utc
25), ordered AS (
26  SELECT
27    user_id,
28    session_date_utc,
29    session_id,
30    session_start_utc,
31    session_end_utc,
32    LAG(session_end_utc) OVER (
33      PARTITION BY user_id, session_date_utc
34      ORDER BY session_start_utc, session_end_utc
35    ) AS prev_end_utc
36  FROM sessions_by_day
37), scored AS (
38  SELECT
39    user_id,
40    session_date_utc,
41    COUNT(*) AS session_cnt,
42    SUM(IFF(prev_end_utc IS NOT NULL AND session_start_utc < prev_end_utc, 1, 0)) AS overlap_cnt
43  FROM ordered
44  GROUP BY 1, 2
45)
46SELECT
47  user_id,
48  session_date_utc,
49  session_cnt,
50  overlap_cnt,
51  overlap_cnt / NULLIF(session_cnt, 0) AS overlap_rate,
52  overlap_cnt > 0 AND overlap_cnt / NULLIF(session_cnt, 0) > 0.05 AS is_flagged
53FROM scored
54WHERE session_cnt >= 5
55  AND overlap_cnt / NULLIF(session_cnt, 0) > 0.05
56ORDER BY overlap_rate DESC, session_cnt DESC;

1version: 2
2
3models:
4  - name: fct_design_exports
5    description: "One row per export action. Grain is export_id."
6    columns:
7      - name: export_id
8        tests:
9          - not_null
10          - unique
11      - name: user_id
12        tests:
13          - not_null
14          - relationships:
15              to: ref('dim_user')
16              field: user_id
17
18# singular test example: tests/no_rowcount_increase_after_user_join.sql
19# Fails if adding dim_user causes duplication.
20with base as (
21  select count(*) as c
22  from {{ ref('fct_design_exports__pre_user_join') }}
23),
24final as (
25  select count(*) as c
26  from {{ ref('fct_design_exports') }}
27)
28select 1
29from base, final
30where final.c > base.c
31

1from __future__ import annotations
2
3import json
4from collections import defaultdict
5from datetime import datetime, timedelta, timezone
6from typing import DefaultDict, Dict, Iterable, Optional
7
8
9def _parse_iso8601_to_utc(ts: str) -> Optional[datetime]:
10    """Parse a common subset of ISO-8601 into a timezone-aware UTC datetime.
11
12    Accepts strings like:
13      - 2026-02-25T12:34:56Z
14      - 2026-02-25T12:34:56+00:00
15      - 2026-02-25T12:34:56.123456Z
16
17    Returns None if parsing fails.
18    """
19    if not isinstance(ts, str) or not ts:
20        return None
21
22    # Normalize trailing Z.
23    if ts.endswith("Z"):
24        ts = ts[:-1] + "+00:00"
25
26    try:
27        dt = datetime.fromisoformat(ts)
28    except ValueError:
29        return None
30
31    # If naive, treat as UTC to avoid silent local timezone bugs.
32    if dt.tzinfo is None:
33        dt = dt.replace(tzinfo=timezone.utc)
34
35    return dt.astimezone(timezone.utc)
36
37
38def count_exports_last_24h(
39    json_lines: Iterable[str],
40    now_iso: str,
41) -> Dict[str, int]:
42    """Count per-user export events in the last 24 hours.
43
44    Requirements:
45      - Stream input, do not load all lines into memory.
46      - Skip malformed JSON or missing required fields.
47      - Ignore events with timestamps in the future relative to now.
48
49    Args:
50        json_lines: Iterable of JSON strings (one event per line).
51        now_iso: ISO-8601 timestamp for the reference 'now'.
52
53    Returns:
54        Dict mapping user_id to export count.
55    """
56    now_dt = _parse_iso8601_to_utc(now_iso)
57    if now_dt is None:
58        raise ValueError("now_iso is not a valid ISO-8601 timestamp")
59
60    window_start = now_dt - timedelta(hours=24)
61
62    counts: DefaultDict[str, int] = defaultdict(int)
63
64    for line in json_lines:
65        if not isinstance(line, str) or not line.strip():
66            continue
67
68        try:
69            obj = json.loads(line)
70        except json.JSONDecodeError:
71            continue
72
73        if not isinstance(obj, dict):
74            continue
75
76        user_id = obj.get("user_id")
77        event_type = obj.get("event_type")
78        event_time = obj.get("event_time")
79
80        if not isinstance(user_id, str) or not user_id:
81            continue
82        if event_type != "export":
83            continue
84
85        event_dt = _parse_iso8601_to_utc(event_time)
86        if event_dt is None:
87            continue
88
89        if event_dt > now_dt:
90            continue
91        if event_dt < window_start:
92            continue
93
94        counts[user_id] += 1
95
96    return dict(counts)
97
98
99if __name__ == "__main__":
100    sample_lines = [
101        '{"user_id":"u1","event_time":"2026-02-24T12:00:00Z","event_type":"export","properties":{}}',
102        '{"user_id":"u1","event_time":"2026-02-25T10:00:00+00:00","event_type":"export","properties":{}}',
103        '{"user_id":"u2","event_time":"2026-02-25T10:00:00Z","event_type":"click","properties":{}}',
104        'not json',
105        '{"user_id":"u3","event_time":"2026-02-26T10:00:00Z","event_type":"export","properties":{}}'
106    ]
107
108    print(count_exports_last_24h(sample_lines, now_iso="2026-02-25T12:00:00Z"))
109

What's striking isn't any single area's weight, it's that the top three areas all demand you reason about Canva's 25B-event-per-day reality: how those events flow in, how they get queried, and how they're modeled into marts that feed the in-house experimentation platform. Candidates who prep these areas in isolation miss the point, because a question about building a weekly-active-editors dbt mart will quickly pull you into discussing Snowflake warehouse sizing or pipeline SLA tradeoffs before you're done answering. From what candidates report, the most common misallocation of study time is grinding Python algorithm problems at the expense of pipeline reliability and data quality patterns, which show up across multiple areas, not just the one labeled for them.

Drill Canva-relevant pipeline, SQL, and modeling scenarios (including the late-arriving event and schema evolution patterns that recur in their interviews) at datainterview.com/questions.

How to Prepare for Canva Data Engineer Interviews

Canva is betting on becoming a connected, end-to-end creative platform with expanded AI capabilities woven into smoother workflows. For data engineers, that bet translates into real work: the company's in-house experimentation platform needs fresh, reliable data to gate product launches, and the event collection system handling 25 billion events creates pipeline challenges you won't find at most companies this side of FAANG. Affinity, part of Canva's family of brands, adds specialized design workflows that likely bring their own data models into the mix.

The "why Canva" answer that falls flat is some version of "I love using Canva for my presentations." What separates strong candidates is specificity about the engineering problems. Canva's team has written publicly about always exploring new programming languages, which tells you something about the culture: they'd rather evaluate tradeoffs openly than cement one toolchain forever. Grounding your answer in that kind of detail, something you actually read from their engineering blog, signals preparation that goes past the product page.

Try a Real Interview Question

1WITH first_event_per_team AS (
2  SELECT
3    team_id,
4    MIN(CAST(event_ts AS DATE)) AS first_event_date
5  FROM team_events
6  GROUP BY team_id
7),
8team_has_active_member_on_first_day AS (
9  SELECT
10    f.team_id,
11    f.first_event_date
12  FROM first_event_per_team f
13  WHERE EXISTS (
14    SELECT 1
15    FROM team_membership_snapshots s
16    WHERE s.team_id = f.team_id
17      AND s.active_from <= (f.first_event_date + INTERVAL '1 day')
18      AND s.active_to   >= f.first_event_date
19  )
20)
21SELECT
22  first_event_date AS event_date,
23  COUNT(*) AS new_active_teams
24FROM team_has_active_member_on_first_day
25GROUP BY first_event_date
26ORDER BY event_date;

Canva's interview process includes a dedicated Coding & Algorithms round, and candidates who assume a data engineering loop is all SQL get caught off guard. The widget above gives you a taste of the algorithmic thinking involved. Practice similar problems at datainterview.com/coding to build fluency with the kind of clean, well-tested code Canva's engineering culture expects.

Test Your Readiness

Use this to find your weak spots, then close them with targeted reps at datainterview.com/questions.