coram ai logo
Coram Ai· Full Stack Role

Coram AI Interview

Result
Ongoing
Posted
3 Oct 2025
512 reads

Summary

I had two interview rounds at Coram AI for a Full Stack Role. The first round involved a coding challenge to validate a 2D grid of video tiles, and the second was a system design interview focused on processing and displaying camera detection events.

How it went

My interview process at Coram AI consisted of two distinct rounds. The first round was a coding challenge where I was presented with a problem to validate a 2D grid of 1x1 video tiles. The task required writing a function to ensure the tiles formed a valid square or rectangle starting at [0,0] with no holes and no overlaps. The prompt provided clear examples of valid and invalid walls, which was very helpful.

The second interview, for a Full Stack Role, was a system design challenge. I was asked to design a comprehensive system to process and display AI detection events from cameras. This involved designing the backend architecture, considering communication protocols, persistence, redundancy, and scaling. Additionally, I had to design two frontend pages: a landing page listing camera status and a daily activity page for a specific camera, which needed to answer questions about event timing, distribution, and concurrent detections. It was a thorough design problem requiring consideration of both backend and frontend aspects.

Questions asked (2)

  1. 01

    Validate a 2D Grid of 1x1 Video Tiles

    Data Structures & Algorithms

    Our website supports creating a 2D grid of videos we call wall, where each video in it is a tile. Before saving a wall, we must validate it.

    The client sends a list of tiles, where each tile encodes its 2D coordinate(s) (x,y) inside the wall as integers. The wall can only include 1x1 fixed sized tiles, the coordinates pair identifies the starting corners of the tile in this case. An example follows (the notation is intended to be language agnostic, it is incidentally the same as python):

    [[0,0],[0,1],[1,0],[1,1]]

    Which means:
    - the wall has 4 tiles;
    - the first tile goes from (0,0) to (1,1);
    - the second tile goes from (0,1) to (1,2);
    - the third tile goes from (1,0) to (2,1);
    - the fourth tile goes from (1,1) to (2,2);

    Task

    Write a function that validates a wall with only 1x1 tiles. You can assume all coordinates are >= 0.

    A wall is valid if:
    1. It has at least one tile;
    2. The tiles form a square or rectangle starting at [0,0] with no holes;
    3. The tiles don't overlap;

    The function returns true if the wall is valid, false otherwise.

    Note: you can model the wall and tiles as you wish.

    Example of a valid wall: [[0,0],[0,1],[1,0],[1,1]]

    Example of a valid wall: [[1,1],[0,1],[0,0],[1,0]]

    Example of a valid wall: [[0,0],[0,1]]

    Example of an invalid wall (containing holes): [[0,0],[1,1]]

    Example of an invalid wall (containing holes): [[0,0],[0,1],[1,0]]

    Example of an invalid wall (overlapping tiles): [[0,0],[0,1],[0,1],[1,1]]

  2. 02

    System Design: Detection Event Processing and Display

    System Design

    Design a system for processing and displaying AI detection events from cameras for a Full Stack Role.

    Context: Our cameras run some fancy AI detection algorithm which produces outputs with the following fields:

    Field Name    Field type    Description
    Camera hash    string    Unique hash of the camera
    Detection type    enum    Person,car,bicycle
    startX    float    Bounding box coordinate
    startY    float    Bounding box coordinate
    endX    float    Bounding box coordinate
    endY    float    Bounding box coordinate
    timestamp    int/string (you choose)    Time of this event
    These events are then batched (e.g. every second) and pushed out.

    You can assume we already store the camera information and they are available in your backend. Last seen time is periodically updated. It is not related to the pushed events:
    Field Name    Field type    Description
    Camera hash    string    Unique hash of the camera
    Camera name    string    Chosen by the user
    Last seen time    time    When the camera was last seen

    System components (this is the stuff you should design):

    Backend

    Design a backend architecture to process the data coming from the cameras. Detections should be stored persistently. You should consider the following:
    • Communication protocol(s)
    • Persistence
    • Redundance
    • Scaling

    Frontend Pages

    Design the following 2 user pages:
    Landing page
    This page lists all the cameras in the system. For each camera we want to show whether it is online or not (online is last_seen_time < 30 s from now). Cameras can change over time (some might be removed/added). The user can click on a camera to be taken to the daily activity page.
    Camera Daily activity page
    This page gives information about detection events for a single camera and a single day of choice. A user should be able to answer the following questions:
    1. When was a person/car/bike event last/first detected?
    2. How are detections distributed per detection type through the day?
    3. Were there at least 4 people around at a given time?
    Think about how to best display this information.

Know someone preparing? Send it to them:WhatsAppLinkedInX

Interviewed at Coram Ai recently?

Write up your rounds while you still remember the questions. It helps the next person more than you would think.

Share your experience
Discussion 0

Questions for the author, or how your own interview compared.

Join the discussion

Sign in with Google to comment or ask the author a question.

No comments yet

Be the first to share your thoughts and start the discussion!