Zillow SWE Intern Interview 2027: Coding Assessment, System Design, and Timeline

A Zillow SWE intern interview in 2027 could involve coding and technical discussion, but the public evidence does not establish one fixed internship loop. Zillow publishes preparation resources for system design, greenfield coding, and refactoring. Those are general software-engineering resources—not proof that every intern receives all three rounds.

Checked September 7, 2026: This research did not verify a specific 2027 SWE internship requisition, application deadline, or two independent candidate reports from that cycle. Treat this as a preparation guide while you verify your posting and invitation, not an announcement that applications are open.

Useful preparation connects code correctness to a housing-search product: selecting the right listings, handling incomplete data, and keeping saved-search alerts trustworthy. For supplementary exercises, use Software Engineer questions on PracHub; the practice set below is cross-company material, not a Zillow internship question list.

What Zillow officially confirms about interviews

Official guidance: Zillow’s interview-prep page includes behavioral preparation using STAR, plus software-development resources covering System Design, Greenfield Coding, and Refactoring Code. It describes greenfield coding as work resembling practical engineering problems, and design as translating customer needs into simple, stable, scalable solutions. The page does not specify a 2027 intern sequence, assessment vendor, cutoff, or duration. Zillow interview preparation.

That distinction changes how you allocate effort. You have a reason to practice building a small feature and discussing its design. You do not have evidence that an internship requires the same architecture depth as a senior role.

Our advice: Ask the recruiter whether your technical session is an asynchronous assessment, live coding, refactoring, or design discussion. Confirm the permitted language, environment, and resources. A platform name alone does not answer those questions: the same tool can host a timed test or an interviewer-led exercise.

Save the exact invitation instead of relying on a general interview guide’s round count. If the invitation explicitly names system design, prepare it. If it names only coding and behavioral interviews, establish readiness there before spending hours rehearsing a large distributed architecture.

Historical internship reports: useful patterns, limited predictions

Candidate report, August 2023: A Reddit author describing their Zillow internship reported a phone interview followed by two final interviews, with coding they considered easy to medium. The author also described shipping an externally facing intern project. This is a first-person historical account, not a current recruiting specification. Historical intern account.

Historical report republished by Taro, July 2023: Another internship experience describes coding and behavioral discussion, with interval, parentheses, and string problems. The page aggregates interview experiences; its reported outcomes and difficulty labels are not representative odds for a future applicant. Taro internship experience.

These accounts justify keeping data structures and live explanation in your preparation. They do not establish that a 2027 candidate will skip an OA, receive a specific number of questions, or finish recruiting within a particular number of weeks.

Be especially careful with search results labelled “2026.” A page’s update year can differ from the interview date, and a software-engineer review may concern an experienced hire. Before adopting a reported round, check the actual role, location, interview date, and whether the author completed that stage.

Coding assessment practice: filter a map correctly

Official product context: Zillow’s help documentation describes location-based searches, map boundaries, price and bedroom filters, and saved searches that provide listing updates. How Zillow home search works.

Original practice exercise—not a reported assessment question: Write a function that returns matching listing IDs inside a rectangular viewport. Each record has a unique ID, latitude, longitude, price, and bedroom count. Include the rectangle’s edges. Exclude listings with an unknown price. Sort results by ascending price, then ID to break ties.

Use a deliberately limited contract: coordinates are valid numbers, prices are nonnegative integers, bedroom counts are integers, IDs are unique strings, and the rectangle does not cross the antimeridian. These assumptions keep the first implementation focused. They are not claims about Zillow’s data model.

def matching_ids(rows, bounds, max_price, min_beds):
    south, west, north, east = bounds
    if south > north or west > east:
        raise ValueError("invalid non-wrapping bounds")

    matches = []
    for row in rows:
        price = row["price"]
        if price is None:
            continue
        inside = (south <= row["lat"] <= north
                  and west <= row["lon"] <= east)
        if inside and price <= max_price and row["beds"] >= min_beds:
            matches.append((price, row["id"]))
    matches.sort()
    return [listing_id for _, listing_id in matches]

Try a viewport spanning latitude 47.5–47.7 and longitude −122.4–−122.2, with a $600,000 cap and at least two bedrooms. Listing A at (47.6, −122.3) costs $550,000 and has two bedrooms. Listing B on the northern boundary costs the same and has three. Both qualify, and the output is A, B because the ID breaks the price tie.

Listing C at longitude −122.1 falls outside the viewport. Listing D has no price and must be excluded, even if its location and bedrooms qualify. These cases expose two common bugs: reversing comparisons for negative longitudes and treating missing data as an ordinary numeric value.

Scanning costs O(n); sorting k matches costs O(k log k). The stored matches use O(k) space. An index might help a much larger dataset, but naming one does not improve the correctness of this first solution.

Test empty input, boundary coordinates, price exactly at the cap, bedroom equality, tied prices, unknown price, and invalid bounds. Then ask how requirements change if the user draws a polygon. Do not pretend a rectangle test now implements an arbitrary shape. Explain the new geometric requirement before choosing an algorithm or library.

Greenfield and refactoring: two ways to test the same contract

Our preparation framework: Greenfield practice starts with the contract and an empty implementation. Refactoring starts with existing behavior that you must understand before changing it. Zillow’s general preparation page names both formats; whether either appears in your internship remains invitation-dependent.

For the map-filter exercise, imagine inherited code contains if not price: continue. Under our numeric contract, that excludes both None and zero. If the specification only excludes unknown values, the condition changes behavior. A zero-priced synthetic record is a useful test even if you would question that value in production.

Add a test demonstrating the current result, clarify the desired result, then make the smallest correction. Next, extract location matching only if doing so makes the rule easier to read or reuse. Renaming every variable and replacing the whole function at once makes it harder to explain which change fixed the bug.

An interviewer can also ask you to preserve the caller’s input order or return full objects instead of IDs. State which behavior changes, update the tests, and avoid mutating the input unexpectedly. This is a more useful rehearsal than repeatedly rewriting a memorized solution until it looks shorter.

When you get stuck, describe the uncertainty precisely. “I need to decide whether ties preserve input order or sort by ID” invites a useful clarification. “The requirements are confusing” does not tell your interviewer where to help.

System design practice: trustworthy saved-search alerts

Original design exercise: A shopper saves a search and wants notifications when new matching listings appear. This exercise uses Zillow’s documented product behavior as context; the following architecture is hypothetical and does not describe Zillow’s internal systems.

Start with the user promise. Does the alert mean “this listing matched when processed,” or “this listing is still available when you open it”? The latter cannot be guaranteed merely by generating an email. Listing status can change after delivery, so the destination page must show current information.

Use a listing store as the authoritative record, a searchable index for candidate discovery, saved-search preferences, and a notification worker. A new or changed listing can trigger matching against relevant searches. Before sending, recheck whether the listing is still active and whether the user’s search remains enabled.

Consider one concrete sequence. An index still shows listing L17 as active, but the authoritative store now marks it withdrawn. A worker finds L17 through the index. If it sends immediately, the shopper gets a stale recommendation. Rechecking the authoritative record suppresses that alert in this example.

That check reduces stale sends; it does not eliminate every race. A listing could change after the recheck. State the limit and decide whether the product can tolerate it, rather than promising perfect freshness from an asynchronous pipeline.

Retries introduce another issue. The worker may successfully send a notification but time out before recording success. Retrying can send a duplicate. Define a notification identity using the user, saved search, listing, and event version. Discuss durable tracking and, where supported, the delivery provider’s idempotency mechanism. Do not claim a database flag alone guarantees exactly-once delivery across an external service.

For search edits, decide whether queued work should use the old filters or the current saved-search version. For unsubscription, check the enabled state at dispatch. These decisions affect what shoppers see and give a design discussion substance before you introduce throughput estimates or infrastructure brands.

If asked to scale, identify the actual bottleneck. Evaluating every listing against every saved search may become expensive; partitioning candidate searches by geography can reduce unnecessary work. Explain how you would verify the improvement without dropping matches near a partition boundary.

Five practice questions and what each develops

These verified PracHub records are tagged to other companies. Use them for transferable skills, not as evidence of Zillow’s question pool. The harder exercises are optional extensions after you can explain a clean baseline.

For project discussion, pick an example where user behavior changed an engineering decision. Perhaps people misunderstood a filter, a slow request made an interface misleading, or an empty state looked like an error. Explain what you measured or observed and what you personally changed. Do not invent user counts to make a small project sound commercial.

Timeline: track the next confirmed event

No universal 2027 application calendar or interview turnaround was verified in this research. Begin with Zillow’s careers page and follow its official job links. A third-party internship landing page is not evidence that a specific role is accepting applications.

Our planning advice: Once you find a relevant requisition, save its ID, posting, application deadline, enrollment requirements, location, and permitted work arrangement. Zillow’s current careers page describes Cloud HQ flexibility as dependent on role and location; do not copy an older intern’s remote-work arrangement into a new application assumption.

Maintain separate dates for application submission, assessment expiry, scheduled interviews, and the recruiter’s expected update. An assessment deadline is not the same as an internship application deadline. If an invitation lacks a time zone or platform instructions, resolve that before the last available evening.

After an interview, follow the update window the recruiter actually gave you. If it passes, send a concise follow-up identifying your role and interview date. If another offer creates a real deadline, communicate it plainly; another candidate’s fast response does not establish your own decision date.

Prepare until you can produce a correct filter, explain a safe refactor, and reason about a stale listing alert. Then deepen the areas your invitation names. This gives you useful technical readiness while keeping uncertain recruiting details in their proper place.

Sources and Further Reading

• Zillow: Official interview-preparation resources
• Zillow: Careers and official job links
• Zillow Help Center: How home search works
• Reddit: Historical Zillow internship account, August 2023
• Taro: Historical software-engineering internship experience, July 2023