Meta Online Assessment (CodeSignal): Format and Prep

Meta gives some software engineering candidates an online assessment, but not all of them. Since 2025, candidates commonly report a proctored, 90-minute CodeSignal test built around one project-style problem with four levels that unlock in order, such as an in-memory database; many others skip it and go straight to a live technical phone screen. Meta's own interview-prep article describes only the live screen, so your recruiter's invite is the final word on whether you get an OA and which format it uses.

This guide covers who reports getting the OA, how the four-level format works, the multi-question variant some early-career candidates report, how the OA relates to the phone screen, and a two-week prep plan. It is a prep guide: the assessment itself must be done on your own, under Meta's and CodeSignal's rules.

Does Meta use an online assessment?

Sometimes. Meta's official article on preparing for the software engineering interview (last updated in 2022) describes the first technical step as a screen with a Meta engineer: 45 minutes, split into about 5 minutes of introductions, 35 minutes of coding and 5 minutes for your questions. It does not mention an online assessment.

Candidate reports from 2025 and 2026 tell a more varied story:

• Some candidates get an OA before any live coding. Prep sites that track Meta loops, such as Hello Interview, describe the OA as a 2025 addition and list it as the first screening step, ahead of the technical phone screen.
• Many do not. The same guides note that not every candidate receives it; plenty are routed straight to the live screen.
• Seniority does not decide it on its own. Hello Interview's guides for junior (E3), mid-level (E4) and senior (E5) loops all describe the OA, so do not assume experience exempts you.
• The order around it varies. Some guides place a recruiter call before the OA, others after it. Either way, the live technical screen usually comes next.

The format candidates report most often

This lines up closely with CodeSignal's own Industry Coding Assessment: one project-based question with four progressive levels and a 90-minute maximum, where candidates "are not necessarily expected" to finish. Meta has not published which CodeSignal product it uses, so treat the match as a strong hint rather than a guarantee. For how CodeSignal scoring and proctoring work in general, see our CodeSignal assessment guide.

How the four levels are built

CodeSignal's published description of its Industry Coding Framework explains what each level is for and how long it typically takes:

Add up those ranges and you can see why finishing is rare: the typical times total 90 to 165 minutes against a 90-minute limit, and CodeSignal says a major factor in assessing candidates is how far they progress in the time allowed. Its sample task is a file hosting service: upload, get and copy files; then search by name prefix sorted by size; then files with a time-to-live; then a rollback to an earlier timestamp.

A September 2025 candidate report of a Meta OA followed the same arc with an in-memory database, where every record is addressed by a key and a field and every call carries a timestamp:

1. Level 1: set and get, plus compare-and-set and compare-and-delete that act only when the current value matches.
2. Level 2: scans that return a key's fields in sorted order, and a version filtered by field prefix.
3. Level 3: values with a time-to-live that expire at timestamp plus TTL.
4. Level 4: reading what a field held at an earlier timestamp, accounting for expirations and later updates.

That candidate found the first two levels easy, finished level 3 with a little over 30 minutes left, and still could not get level 4 to pass. Expect a different domain on your test; the structure matters more than the specific prompt.

The other version: separate coding questions

Not every Meta OA uses the progressive format. Hello Interview's junior-level guide says some early-career candidates in 2026 report four unrelated LeetCode-style questions, easy to medium, in about 70 minutes instead. The same guide notes that a few candidates describe the OA as their main coding gate, with no separate technical phone screen afterward, so ask your recruiter which applies before you plan your prep.

If your invite looks like this version, shift your prep toward speed on standard patterns: arrays and strings, hash maps, two pointers, sliding window, grid BFS and DFS, and straightforward simulation. Our new grad online assessment guide covers how to take and practice for multi-question OAs.

The rules: do it on your own

The OA is proctored, and the rules screen shown before you start is the rulebook. Read it fully. Third-party guides report that checking syntax references is allowed while searching for solutions or using AI tools is not, but the rules on your screen override anything you read elsewhere, including here.

• Work alone, start to finish. No other people, no AI tools, no solution searches and no outside help of any kind during the assessment.
• Run the system check early. Camera, microphone, browser and network problems are far easier to fix the day before than ten minutes into a timed session.
• Skip the hunt for leaked prompts. Prompts vary, and the skill being measured is building something new under time pressure. That is exactly what you can practice.

How the OA compares with the phone screen

Passing the OA typically leads to the live screen. Hello Interview notes that Meta weighs OA results alongside the phone screen, so a weaker OA means the screen has to be stronger to make up for it. That suggests the OA bar is not perfection, but Meta does not publish a cutoff, so aim to bank as many fully passing levels as you can. For the live rounds and their two-problems-per-round pace, see our Meta coding interview questions guide.

A two-week prep plan

The OA is silent, but the round after it is not. For the speaking half, a free AI mock interview in CoPilot Interview lets you choose coding questions, answer out loud and get a score on each answer with what worked and what to improve, which is closer to the phone screen than solving alone. For the wider loop, our FAANG interview prep guide lays out the system design and behavioral prep that comes next.

Design level 1 so level 4 does not break it

The most expensive mistake in a progressive OA is a level 1 design that cannot absorb later requirements, forcing a rewrite at the 60-minute mark. A few habits prevent it:

• Read every level overview before coding. Guides that track Meta's OA say a high-level overview of every level is visible at the start, with detailed requirements revealed as each level unlocks. If an overview mentions time or history, design for it now.
• Append instead of overwrite. If calls carry timestamps, keep every version. Expiry and point-in-time reads then become lookups, not rewrites.
• Route every read through one helper. When expiry arrives, you change one function instead of five.
• Match signatures and return formats exactly. The tests call methods by name and compare outputs literally.

Here is a Python sketch of that idea for a key-and-field store. It assumes the prompt guarantees timestamps never decrease, which the 2025 report describes; check your own spec.

from bisect import bisect_right
from collections import defaultdict

class InMemoryDB:
    def __init__(self):
        # key -> field -> ([ts, ...], [(value, expires_at), ...])
        self.data = defaultdict(dict)

    def _write(self, ts, key, field, value, ttl=None):
        expires = ts + ttl if ttl is not None else float("inf")
        times, vals = self.data[key].setdefault(field, ([], []))
        times.append(ts)
        vals.append((value, expires))

    def set(self, ts, key, field, value, ttl=None):
        self._write(ts, key, field, value, ttl)

    def delete(self, ts, key, field):
        self._write(ts, key, field, None)  # tombstone

    def get_when(self, at_ts, key, field):
        times, vals = self.data.get(key, {}).get(field, ([], []))
        i = bisect_right(times, at_ts) - 1
        if i < 0:
            return None
        value, expires = vals[i]
        return value if at_ts < expires else None

    def get(self, ts, key, field):
        return self.get_when(ts, key, field)

    def scan(self, ts, key, prefix=""):
        out = []
        for field in sorted(self.data.get(key, {})):
            value = self.get_when(ts, key, field)
            if field.startswith(prefix) and value is not None:
                out.append((field, value))
        return out

Because every write appends, a plain get is just a point-in-time read at the current timestamp, expiry is one comparison, and a delete is a tombstone. The scan reuses the same helper, so expired and deleted fields drop out of sorted and prefix-filtered results without extra code.

Test-day tactics

1. Pass the tests, then polish. Guides that track Meta's OA say correctness matters more than speed and that constraints mainly block very slow solutions.
2. Budget by level. CodeSignal's framework suggests about 10–15 minutes for level 1 and 20–30 for level 2. If level 1 is taking 30, simplify.
3. Debug with the failing input. Candidates report that each level unlocks only after the previous one passes, so a stubborn bug blocks everything after it. Reproduce the failing case in the scratch area instead of rereading code.
4. Submit early and often. CodeSignal's sample task grants partial credit for each passed test, and its Industry Coding Assessment scores run from 200 to 600, with higher scores meaning more of the assessment completed. Every test you turn green counts, even on a level you never finish.

FAQ

Does every Meta software engineer candidate take an online assessment?

No. Candidate reports since 2025 show some candidates take a proctored CodeSignal OA first, while many go straight to the live technical phone screen. Your recruiter will tell you which applies to you.

How long is the Meta online assessment?

The most commonly reported version is 90 minutes on CodeSignal, with one problem split into four levels. Some early-career candidates report a version with four separate questions in about 70 minutes instead.

Do I need to finish all four levels to pass?

Probably not. Guides that track Meta loops say most candidates do not finish all four, and Meta does not publish a cutoff, so aim for clean, fully passing early levels before chasing level 4.

Can I use AI tools or look things up during the Meta OA?

No AI tools and no outside help. The assessment must be done on your own, and the rules shown before you start, including any limits on reference material, are the ones to follow exactly.

Can I retake the Meta online assessment?

Ask your recruiter. If your test is CodeSignal's standard Industry Coding Assessment, CodeSignal allows two attempts in a rolling 180-day window, and only with a new invitation from the company, so you cannot simply retake it on your own.

What comes after the Meta OA?

Usually a live 45-minute technical screen with a Meta engineer, then the full interview loop, though a few candidates report the OA replacing that screen. Meta's own guidance describes about 35 minutes of coding in the screen.