An ex-coworker founded a YC company in the W23 batch and pinged me in early summer of that year. They were 4 engineers, the seed round had closed three weeks earlier, and they were trying to make a key hire before the founders left for a conference. The recruiter (the technical co-founder, doubling) told me on the first call: "if you and I both want to keep going after the technical round, we will run the rest of the loop tomorrow and decide within 24 hours of your last interview". I had never seen this shape before, and the speed itself was a signal worth writing down.

The full loop in 26 hours

The pacing is the story:

Wednesday
  9:30 am  intro call with technical co-founder, 30 min
  4:00 pm  technical round, 60 min, with the same co-founder
Thursday
  10:00 am pair programming on a real bug, 60 min, with their senior engineer (employee #1)
  2:00 pm  founder round, 45 min, with the CEO co-founder
  4:30 pm  call from the technical co-founder with verbal offer + comp
  end of day Thursday: written offer in my inbox

Four rounds in 26 elapsed hours. The recruiter said the speed was deliberate: "slow loops let candidates over-think and let us over-think; we have made better hires when we trust the first read". That is a defensible position when you are 4 engineers. It is also a position that has costs, and I want to be honest about both.

What the technical round was grading

The technical round was 60 minutes, one problem. The problem was a real one from their codebase, paraphrased here because the actual problem touched their not-yet-public product.

The shape was: given a stream of customer events, deduplicate them by a content-derived key, but allow a configurable time window during which the same key was treated as new (so a customer who logged the same event 30 days later was counted again). The interviewer wanted me to write the deduplication store. He gave me 50 minutes for code, 10 for follow-ups.

I wrote a small in-memory implementation backed by a hash map keyed by the content key, with each entry storing the last-seen timestamp. Read path checks the map; write path either inserts or updates the timestamp; a separate sweep eviction job runs on an interval and removes entries older than the window. I wrote it in TypeScript because that was their stack.

type DedupeStore = {
  seen: (key: string, now: number) => boolean;
  evict: (now: number) => void;
};

function createDedupeStore(windowMs: number): DedupeStore {
  const map = new Map<string, number>();
  return {
    seen(key, now) {
      const prev = map.get(key);
      if (prev !== undefined && now - prev < windowMs) {
        return true;
      }
      map.set(key, now);
      return false;
    },
    evict(now) {
      for (const [k, ts] of map) {
        if (now - ts >= windowMs) map.delete(k);
      }
    },
  };
}

The follow-ups were the round. The interviewer asked me to think through what breaks at 100 million keys (the map fits in memory at maybe 5 million on a small instance, so we need either eviction more aggressive than the window or an external store). He asked what happens if the eviction sweep is delayed (false positives where a key that should have been evicted is still treated as a duplicate). He asked what to do if the same key arrives concurrently on two workers. The answers are not exotic, but he was watching whether I was tracking the operational consequences of the toy implementation, not just the toy implementation. I was.

What the founder round was actually grading

The founder round was 45 minutes with the CEO. He had not seen my code. He had read my background and the technical co-founder's two-line writeup of the technical round. He spent the first 10 minutes describing the company in a way I had not heard from public sources, including a specific bet they were making that I had not picked up from the YC demo day video. Then he asked me three questions, in order:

1. "What is the worst job you have ever had, and what did you learn about yourself from it"
2. "What are you not going to enjoy about working here in the first 6 months"
3. "If we hire you, what would make you leave inside the first year"

All three questions were grading the same thing: do you tell the truth when the truth is unflattering. The first question is easy if you have a story; the second one breaks most candidates because the polite answer is "I will love it" and the polite answer is wrong. The third one is the hardest. I told him the honest answer, which was that I would leave inside a year if the founders were not the kind of people who would tell me when I was failing. He smiled and said "we are". The rest of the round was logistics.

The 24 hour decision and why I declined

The verbal offer came at 4:30pm Thursday, exactly as the recruiter had said. The comp was lower than my current job and the equity was real but unmarked-up early-stage equity.

I declined on Sunday. The reasons are worth writing down because they are not the obvious ones. The loop was sharp and the founders were thoughtful. What I could not get past was that the loop's pacing was a small signal of a larger pattern: this team was optimizing for speed over reflection at every layer, and the founders had said so explicitly. That is a defensible mode for a 4 person company that needs to ship to survive. It is also a mode I had lived in and was trying to leave.

I sent a 6 line decline email naming the reason. The CEO replied with a 2 line note that ended "that is the right reason, and we'll keep your name on a short list if the company shape changes". That was the most honest interview correspondence I had ever had. If the loop had been longer I might have talked myself into the offer. The 24 hour loop forced me to face the actual question.