My AI-Powered Coding Interview Experience with micro1

AI-driven questions and a WebRTC-related coding challenge

The article was posted: 3/1/2025| 5 min read

---

I recently had a rather curious experience—being interviewed by AI. The entire process took about one hour, with the first 30 minutes dedicated to an AI assistant asking questions, recording my responses, and analyzing them. The final 25 minutes consisted of a coding interview.

For the first part you had to answer the questions (I might have forgotten something, but the list is pretty exhaustive).

• Introduce yourself
• How would you optimize a React app with a lot of components?
• How would you handle a Node.js app with a lot of concurrent requests?
• Your Node.js app is connected to AWS services. Give an example of how you would scale the app.
• How to handle PostgreSQL replication?
• How would you shard a PostgreSQL database?
• How to avoid large bills when scaling AWS services?
• How to handle a lot of concurrent requests to a PostgreSQL database?
• How would you utilize WebRTC to stream video in high quality without packet loss?

The platform I used was micro1. Here is a 4-minute walkthrough showing what the interview process looks like.

Since the job involved WebRTC, the coding task was somewhat related. For those unfamiliar, WebRTC is a protocol that enables real-time voice and video communication through the browser. It can transmit packets over both UDP and TCP:

• TCP ensures packet delivery integrity and order but is slower.
• UDP is faster but does not guarantee reliability — packets may be lost or arrive out of order.

The task was as follows:

Imagine you have a batch of UDP messages. Each message consists of a string and a timestamp (a number). The messages may arrive out of order, and duplicates (messages with the exact same timestamp) may exist. Your task is to write a function that returns the longest correct sequence of messages from the given batch.

const batch = [
    { timestamp: 1, message: "Message 1" },
    { timestamp: 3, message: "Message 3" },
    { timestamp: 4, message: "Message 4" },
    { timestamp: 6, message: "Message 6" },
    { timestamp: 5, message: "Message 5" },
    { timestamp: 2, message: "Message 2" }
];

const batchWithDuplicates = [
    { timestamp: 1, message: "Message 1" },
    { timestamp: 3, message: "Message 3" },
    { timestamp: 4, message: "Message 4" },
    { timestamp: 4, message: "Message 4" },
    { timestamp: 3, message: "Message 3" },
    { timestamp: 6, message: "Message 6" },
    { timestamp: 5, message: "Message 5" },
    { timestamp: 2, message: "Message 2" }
] 

// For instance, for both batches the function should output
[{
  "timestamp": 1,
  "message": "Message 1"
}, {
  "timestamp": 3,
  "message": "Message 3"
}, {
  "timestamp": 4,
  "message": "Message 4"
}]

In batch the first message out of order is the one with timestamp 6. Same is true for batchWithDuplicates, but it also contains duplicates.

interface Message {
    timestamp: number;
    message: string;
};

type Batch = Message[];

function sequencer(batch: Batch) {
    const timestamps = new Set();
    const sequence: Batch = [];
    let maxCurrentTimestamp = null;
    
    for (const el of batch) {
        // Skip duplicates
        if (timestamps.has(el.timestamp)) {
            continue;
        }
        
        // Stop if timestamp is out of order
        if (maxCurrentTimestamp !== null && el.timestamp < maxCurrentTimestamp) {
            break;
        }
        
        // Add to sequence and update maximum timestamp
        sequence.push(el);
        timestamps.add(el.timestamp);
        maxCurrentTimestamp = el.timestamp;
    }
    
    // Return the sequence without the last element if there is more than one element
    return sequence.length > 1 ? sequence.slice(0, sequence.length - 1) : sequence;
}

const batch = [
    { timestamp: 1, message: "Message 1" },
    { timestamp: 3, message: "Message 3" },
    { timestamp: 4, message: "Message 4" },
    { timestamp: 6, message: "Message 6" },
    { timestamp: 5, message: "Message 5" },
    { timestamp: 2, message: "Message 2" }
] satisfies Message[];


const batchWithDuplicates = [
    { timestamp: 1, message: "Message 1" },
    { timestamp: 3, message: "Message 3" },
    { timestamp: 4, message: "Message 4" },
    { timestamp: 4, message: "Message 4" },
    { timestamp: 3, message: "Message 3" },
    { timestamp: 6, message: "Message 6" },
    { timestamp: 5, message: "Message 5" },
    { timestamp: 2, message: "Message 2" }
] satisfies Message[];

console.log(sequencer(batchWithDuplicates), sequencer(batch));