Companies

Algorithm-heavy loops with a high bar for code quality and complexity analysis. Googleyness rounds probe collaboration and comfort with ambiguity.

Every interview weaves in the Leadership Principles — expect a behavioral question in each round, with follow-ups that dig for data and ownership.

Fast-paced coding rounds — two problems in 45 minutes is common — plus a product-minded design round and a dedicated behavioral round.

Practical over puzzle: expect to write working code in a real editor, debug an unfamiliar codebase, and design APIs with careful edge-case handling.

Senior-leaning loops that weigh judgment and culture heavily — expect deep dives on past architecture decisions alongside coding.

Product-minded loops with practical coding rounds — string and array manipulation with fiddly edge cases shows up often, and design rounds stay grounded in surfaces like feeds and boards.

Consumer fintech loops that stay close to the product: practical data-structure rounds over state that changes as users move through an app, a design round grounded in money movement, and a values round built on the member-first framing used throughout the company.

Product-engineering loops with a practical bent: data structures first, then a design round grounded in the app surface you would actually work on.

Lending-flavored loops: practical coding, a design round on payments and risk, plus a behavioral round.

Loops with unusual weight on collaboration: a pairing-style coding round, an architecture round, and a dedicated core-values interview.

Global-payments loops pairing coding rounds with design questions about multi-currency ledgers and regional rails.

Hardware-adjacent loops built on C and systems fundamentals, plus performance-oriented design questions that vary by team.

Defense-technology loops with systems depth — C++ or Rust rounds, real-time constraints, and questions about software that has to work in the field.

Go-to-market SaaS loops with practical coding and design questions about data enrichment and outbound workflows.

Deeply team-specific loops — questions follow the domain of the team you interview with, and debugging instincts and low-level detail carry real weight.

Autonomy-tooling loops with strong C++ or Python rounds, simulation-flavored design questions, and domain conversations.

Research-oriented loops pairing statistics and probability with coding, plus discussion of how models fail in practice.

Financial-technology loops with a heavy data-modeling component — algorithms, SQL, and design questions about post-trade systems.

Collaborative loops with practical coding, a design round on real-time collaboration, and real emphasis on how you work with other people.

Values-forward loops — coding and design rounds plus a dedicated values interview that carries real weight in the decision.

Messaging-platform loops — practical coding plus design questions about high-volume sends, opt-ins, and deliverability.

Tax-compliance SaaS loops: practical coding plus design questions about rules engines, rate data, and correctness at scale.

Custody-focused loops where security reasoning matters as much as code — key management, threat modeling, and distributed systems.

Technology loops inside a finance-first culture — algorithms and design rounds plus conversations about working directly with business stakeholders.

Practical loops across the Square and Cash App surfaces — real code, product-minded design rounds, and a values conversation.

Practical loops with a strong C++ and data-structures core, then a design round and questions about handling real-time market data.

Cloud-content loops: standard coding rounds plus design questions about storage, permissions, and enterprise integrations.

Fast, practical fintech loops — a coding exercise close to real work, a design round on card and ledger systems, and a hiring-manager conversation.

Loops that probe reasoning and self-awareness as hard as technical skill — expect direct feedback in the room and questions about how you actually think.

Multi-round algorithm-heavy loops — typically several coding interviews in sequence, followed by design and HR rounds.

Stablecoin-infrastructure loops — coding rounds plus design questions about ledgers, settlement, and blockchain integration.

Rigorous quantitative loops — algorithms with tight complexity expectations, probability, and questions about how your systems behave under latency and load.

Crypto-native loops: coding rounds, a design round on custody, ledgers, or exchange infrastructure, plus a values interview.

Streaming-infrastructure loops: algorithms plus deep design questions about logs, partitions, and delivery guarantees.

Consumer-finance loops with practical coding rounds and design questions about recommendations and personal-finance data.

Security loops pairing systems coding with threat-detection reasoning and design questions about telemetry at scale.

Trading loops that combine timed math assessments with algorithms and conversations about market intuition.

Systems-heavy loops — strong algorithms, distributed data-processing questions, and design rounds about query and storage layers.

Observability loops with practical coding, a design round on high-volume metrics ingestion, and a systems conversation.

Analytically demanding loops — probability, combinatorics, and algorithms, with a clear preference for candidates who reason precisely under pressure.

Enterprise-SaaS loops with standard coding rounds and design questions about documents, signatures, and audit trails.

Marketplace loops — coding rounds, a design round on logistics and real-time dispatch, and a behavioral round.

Loops that favor clean, working code over cleverness, with design rounds about storage, sync, and sharing.

Quantitative loops that mix low-latency systems questions with probability and algorithms, tuned to the desk you would support.

Learning-product loops that pair practical coding with product sense and design questions about lessons and experimentation.

Games loops tuned to the discipline — C++ and engine questions for gameplay roles, services design for online teams.

Consumer-fintech loops with practical coding and design questions about earnings data, risk, and payout timing.

Marketplace loops with standard coding rounds and design questions about catalogs, search, and payments.

Wholesale-marketplace loops: practical coding, a design round on catalog and ordering, plus a hiring-manager conversation.

Logistics loops with practical coding and design questions about shipments, tracking, and genuinely messy real-world data.

Structured loops with a technical assessment, algorithm rounds, and a superday of back-to-back interviews spanning code and behavior.

NLP-adjacent loops pairing algorithms with design questions about latency-sensitive suggestions across every editor they plug into.

Quantitative research loops — statistics, probability, and coding, with follow-ups that dig into how you would test a signal.

Payroll-and-benefits loops with practical coding, a design round on money movement and compliance, plus a values conversation.

Enterprise-SaaS loops pairing practical coding with design questions about search, content, and integrations.

Algorithms and systems at speed — deep C++ or Python rounds, performance questions, and probability puzzles.

Trading-firm loops with a timed math and logic assessment up front, then probability, algorithms, and rounds with traders.

Marketplace and logistics loops: practical coding, a design round on catalog and fulfillment, plus a behavioral round.

Probability, mental math, and market-making games matter as much as code — you are graded on the reasoning you say out loud, not the answer you land on.

Low-latency engineering loops: C++ and systems depth, cache and concurrency questions, plus probability and algorithms.

Loops that pair standard coding rounds with a strong host and behavioral component, plus design questions grounded in feeds, graphs, and search.

Loops that lean on practical engineering judgment — clean code, testing, and how you handle ambiguity matter as much as finding the optimal algorithm.

Platform-oriented loops where engineering rounds are tailored to the pod or desk you would support, alongside quantitative reasoning.

Collaboration-canvas loops: practical coding plus design questions about real-time sync and conflict resolution.

Analytics loops: coding rounds plus design questions about event ingestion, funnels, and fast queries over very large datasets.

Ad-ML loops where algorithms meet real-time serving — coding rounds plus design questions about bidding and model latency.

Database loops where storage engines, indexing, and consistency questions sit alongside standard coding rounds.

Enterprise-AI loops pairing coding rounds with design questions about retrieval, agents, and integrating with a company's existing systems.

Local-network loops: coding rounds plus design questions about feeds, moderation, and geographic partitioning.

AR-platform loops: coding rounds plus design questions about location data, mapping, and mobile clients at scale.

Craft-focused loops — a practical coding exercise close to real product work, a design round, and conversations about taste and product sense.

Autonomy loops where algorithms meet robotics constraints — coding rounds, a systems round, and safety-oriented discussion.

Systems-flavored loops where memory hierarchy, parallelism, and performance questions show up next to standard algorithms, tuned to the team.

Identity loops: coding rounds plus design questions about authentication, tokens, and multi-tenant access control.

Exchange loops with algorithm rounds and design questions about matching engines, latency, and wallet infrastructure.

Research-adjacent loops with strongly practical coding — real problems in a real editor, systems questions about training and serving, and conversations about safety trade-offs.

Market-making loops that start with timed mental-math and pattern tests before any code, then move into probability and technical rounds.

Loops built around decomposing a vague, messy problem — expect an open-ended design conversation alongside practical coding.

Creator-platform loops with practical coding rounds and design questions about payouts, memberships, and creator tooling.

Investment-technology loops mixing algorithms and systems design with questions about data quality and research workflows.

Self-driving loops with strong algorithm rounds, C++ depth, and domain questions tied to perception or planning.

Storage-systems loops where C, memory, and performance questions matter, plus design rounds on durability and throughput.

Embedded and systems loops — C, memory, and concurrency dominate, tuned to the silicon or platform team you are joining.

Experience-management loops with standard coding rounds, a design round on surveys and analytics, and a values interview.

Loops grounded in the product: coding rounds, a design round on feeds and ranking, plus a values conversation.

Remittance loops with practical coding rounds and design questions about payouts, compliance, and reliability.

Games loops with practical coding, gameplay or services design questions, and a culture round centered on players.

Payments-infrastructure loops with coding rounds and design questions about cross-border settlement and distributed ledgers.

Fast, practical loops — a realistic coding exercise, a design round spanning HR, IT, and payroll systems, and a hiring-manager round.

Loops built around trading surfaces — coding rounds, a design round on order flow and real-time data, plus a behavioral round.

Platform loops spanning engine, backend, and safety — coding rounds plus design questions about user-generated content at scale.

Ecommerce-adtech loops pairing algorithms with design questions about real-time bidding and personalization.

Streaming-platform loops spanning device and cloud — coding rounds plus design questions about playback, ads, and constrained hardware.

Data-management loops with distributed-systems depth — coding rounds, then design questions about backup, recovery, and consistency.

Enterprise-scale loops — data structures, then multi-tenant design questions and a values round built around the company's Ohana framing.

IoT loops spanning embedded, cloud, and mobile — coding rounds plus design questions about fleets of devices all reporting at once.

Data-infrastructure loops for machine learning: practical coding, pipeline design questions, and discussion of labeling quality at scale.

Developer-tooling loops that favor real code over puzzles, with design questions about event ingestion and error grouping.

Loops built around decision-making under uncertainty — poker-style reasoning and probability alongside algorithms, with attention to how you handle incomplete information.

News-app loops with algorithm rounds and design questions about ranking, personalization, and mobile delivery.

Fast-paced loops with camera and mobile-flavored design questions alongside standard coding rounds.

Consumer-finance loops with standard coding rounds and design questions about accounts, transfers, and compliance-aware systems.

Loops that pair practical coding with a design round on streaming and recommendations, and a strong culture component.

Data-driven quant loops: algorithms, statistics, and systems questions, tuned toward the research or engineering track you apply for.

Endpoint-management loops with systems depth — coding rounds plus design questions about distributing work across very large fleets.

Algorithm-heavy loops with several technical rounds, a design discussion, and a final conversation with a senior manager.

High-volume loops with several algorithm rounds, often back to back, then a design round and a hiring-manager conversation.

Consumer-scale loops with coding rounds and design questions about matching, recommendations, and real-time messaging.

Latency-sensitive loops pairing strong algorithms with systems and networking questions, plus quantitative reasoning.

Programmatic-advertising loops where latency is the constraint — algorithms plus design questions about bidding at very high request rates.

Live-video loops — coding rounds plus design questions about chat, streaming, and real-time scale.

Research-flavored loops: strong algorithms, statistics, and a systems round, with follow-ups that probe how you validate your own conclusions.

Fast, practical loops — coding rounds under real time pressure, then a design round on marketplace and real-time systems.

Engine and tooling loops — C++ or C# depth, graphics and performance questions, plus design rounds tied to the editor or runtime.

Lending and ML-flavored loops — coding rounds plus questions about models, features, and how automated decisions get audited.

Unstructured, conversation-driven loops — deep technical discussion and questions about what you would choose to work on with no one assigning it.

Hardware-plus-cloud loops: practical coding, systems design for video at scale, and questions about managing devices in the field.

Infrastructure loops where virtualization, operating systems, and concurrency questions sit alongside the usual algorithms.

Autonomy loops where algorithms meet robotics — coding rounds, a systems round, and domain questions tied to perception or planning.

Automated-investing loops: clean coding rounds plus design questions about portfolios, tax logic, and getting the numbers exactly right.

Live-commerce loops — practical coding plus design questions about live video, bidding, and payments under load.

Cross-border payments loops: practical coding, a design round on money movement and FX, plus a values conversation.

Lean, fast loops with a strong bias toward shipping — practical coding, systems questions, and direct conversations with the team you would join.

Consumer real-estate loops: coding rounds plus design questions about search, listings, and the data pipelines behind them.

Robotics loops spanning perception, planning, and infrastructure — coding rounds plus domain-specific design questions.