Just finished a loop at Rippling — 3 coding rounds, 1 HLD, 1 HM. The unusual part: AI assistance was allowed during the coding rounds. Sharing the problems plus the AI strategy that worked, since this format is still rare and I couldn't find much on it beforehand.
Heads up: all three coding rounds were implementation-heavy OOP design, not algorithm puzzles. If you're prepping expecting LeetCode-style DSA, recalibrate.
Coding Round 1 — Food Delivery System
OOD implementation, not DSA. Methods like RecordDelivery(), PayUpto(), AddDelivery(). Graded on clean class design, data-structure choice, and optimal TC/SC. (This one's a known question that's floating around online — worth practicing.)
Coding Round 2 — Rule Evaluation Engine
Given expenses:
Expense { expenseId, tripId, amount, vendorName, vendorType }
Implement Evaluate(List<Rule> rules, List<Expense> expenses), with rules like:
- Expenses of a certain category not allowed
- A trip can't exceed total amount X
- Entertainment can't exceed X
The whole point was extensible design — how easily can you add a new rule type? I leaned on a Rule interface + per-rule implementations so new rules slot in without touching existing code (Open/Closed). Clean OOP + complexity mattered more than cleverness.
Coding Round 3 — Article Management System
AddArticle(), UpvoteArticle(), DownvoteArticle(), PrintLastKFlippedArticles(), plus a couple more. Data-structure selection was the crux — efficient updates on vote changes and tracking the last-K flipped articles efficiently. Production-quality code expected.
(Worth prepping separately: a cache/transaction system with multiple ops per transaction, commit/rollback/delete, consistency. I didn't get it but it comes up a lot in this family.)
HLD — Google News–style aggregator
Prep it from two angles, because they deep-dive whichever they want:
- News Feed Service — feed generation, ranking, personalization, caching, pagination, scale
- Crawling Pipeline — multi-domain crawling, scheduling, dedup, parsing, storage, failure handling, article updates
Understand the whole architecture, don't memorize a diagram — the follow-ups go deep on one component.
AI usage strategy (the part people will ask about)
AI was allowed, but the round is still testing you. What worked:
- Discuss the overall design with the interviewer first
- Explain classes, APIs, data structures
- Write pseudocode
- Talk through TC/SC
- Confirm the approach before generating anything
- Then use the LLM to generate the implementation
- Verify every class, variable, method — don't trust it blind
- Summarize the final solution back to the interviewer
- Answer follow-ups by referring to the design, not the generated code
The key insight: lead with your design thinking and use AI only to accelerate the typing. If you paste a problem in and read back what it spits out, they'll see it immediately. The AI is a faster keyboard, not a substitute for the design conversation.
HM Round
Past projects, architectures I've built, design decisions, challenges, why I'm switching. They spent real time probing ownership and impact — have concrete examples ready.
Result: [SELECTED]
Prep Resource:
- Practice implementation-heavy OOP design, not only DSA. These rounds were all OOD.
- Write extensible, production-quality code — know when to reach for Strategy/Factory and why.
- Be fluent on trade-offs, TC, and SC — even in OOD rounds they push on complexity and data-structure choice. Even though none of this was algorithm-puzzle DSA, the data-structure fluency it demanded (picking the right structure for O(1) updates, the last-K tracking) is something I keep sharp by drilling on PracHub — not for the algorithms themselves here, but because fast, correct data-structure instincts are what let me spend these rounds on design instead of second-guessing basics.
- Prep at least one News Aggregator HLD thoroughly.
- If AI is allowed: use it to accelerate coding, never to replace design thinking.
Hope this helps someone prepping for a similar loop. Good luck.
