Remitly Software Engineer interview questions & guide 2026

Interview questions at Remitly reflect practical software engineering challenges rather than abstract theoretical riddles. Every technical round—from the phone screen to the full loop—allocates dedicated time for both domain coding/design and structured behavioral evaluation using the STAR method.

Object-Oriented Design & Domain Modeling

These questions evaluate your ability to design clean, extensible class interfaces, write maintainable data models, and implement realistic domain logic.

• Substitution Cipher Validation: Given a string and a list of candidate words, determine which words are isomorphic to the target string; extend the class to cache mapping rules for high-frequency callers.
• Elevator Controller System: Implement an object-oriented elevator iterator supporting registerFloor(int floor) and nextAction(), returning directional actions (GO_UP, GO_DOWN, STOP, MOVE_DOORS) while optimizing move scheduling.
• Deck of Cards & Card Shuffler: Model a deck of cards using clear domain abstractions, and implement an unbiased shuffling algorithm with extensible interfaces to support unit testing and custom shuffle mechanisms.
• Task Scheduler with Weighted Random Selection: Build a class to manage asynchronous tasks supporting add(Task task, int weight) and a pickTask() method that selects a task with probability proportional to its weight.
• String Template Interpolation: Parse a template string containing placeholder keys (e.g., "this is a {foo} {bar}") and replace them with mapping values from a given key-value collection.

Algorithmic Problem-Solving & Streaming Data

These problems test your foundational data structure choices, error handling, and efficiency when handling continuous streams or state adjustments.

• Bank Account Balance & Threshold Transfer: Given a set of bank accounts with varying balances and a required threshold, calculate the minimal set of transfer operations to ensure every account meets the threshold while cleanly handling funds shortfalls.
• Currency Stream Parsing: Parse an incoming, non-peekable character stream containing prefixed monetary values (e.g., $300, £400) and extract valid numeric values associated with a target currency symbol while handling malformed tokens.
• Event Telemetry Sliding Window: Build a telemetry streaming engine that receives time-stamped events and computes sliding window aggregate counts over arbitrary durations.
• Two-Sum Stream Processing: Implement a data structure that ingests a continuous stream of integers and efficiently evaluates whether any pair sums to a specified target value.

System & Distributed Architecture Design

These scenarios assess your capacity to build fault-tolerant systems, scale high-throughput integrations, and architect resilient data processing pipelines.

• Unreliable Third-Party API Integration: Design a resilient backend service that integrates with a low-reliability, high-latency external IP reputation API, incorporating aggressive caching, asynchronous fallbacks, and audit logging.
• Merchant Appointment Sync Service: Architect a data ingestion platform to poll appointment availability across 100,000 distinct merchants every 10 minutes, using external rate-limited APIs (GET /appointments?start_date=<>&end_date=<>), worker pools, storage layout, and monitoring alerts.
• Periodic Timer Dispatcher: Implement a custom periodic timer function setIntervals(durations[], callbacks[]) operating on top of a single restrictive core timer primitive (setSystemTimer) that throws exceptions if invoked while active.
• URL Shortening & Redirection Service: Design a globally distributed URL shortening platform, focusing on unique key generation, high-read caching strategies, data persistence, and analytics logging.

Leadership & Cultural Alignment (Behavioral)

Behavioral questions are integrated into every single interview round at Remitly. Candidates are expected to frame responses explicitly around impact, customer empathy, and collaboration.

• Describe a situation where you had a strong disagreement with a peer or team lead regarding a technical decision. How did you resolve it?
• Tell me about a time you had to make a high-stakes technical decision under tight time constraints or with incomplete data.
• How do you approach mentoring junior software engineers or raising the technical quality bar across your engineering organization?
• Describe a time when a project or deliverable was falling behind schedule. How did you communicate the delay to stakeholders, and what mitigation steps did you propose?
• How do you balance delivering business value quickly with managing technical debt in critical legacy infrastructure?

Preparing for an interview at Remitly requires a balanced focus on practical software construction, low-level object modeling, scalable backend architecture, and cultural alignment. Interviewers evaluate code readability, defensive validation, and operational clarity over complex algorithmic tricks.

Role-Related Engineering Depth – You must demonstrate proficiency in object-oriented design patterns, concurrency controls, clean domain abstractions, and robust error handling. Interviewers evaluate whether your code is structured for production maintainability, including clear separation of concerns, testability, and edge-case validation.

System Architecture & Pragmatic Design – You are expected to design real-world distributed systems with an emphasis on fault tolerance, rate limiting, data storage selection, and asynchronous queuing. Evaluation centers on your ability to handle real-world trade-offs such as network latency, partial service outages, and eventual consistency in payment workflows.

Collaborative Execution & Communication – Technical rounds are highly collaborative. Interviewers assess how well you articulate your design trade-offs, drive requirements gathering, incorporate feedback during live coding, and structure your thought process out loud.

Customer Focus & Cultural Values – Remitly places significant weight on core cultural values like Earning Trust, Customer Centricity, and Constructive Directness. Every interviewer will spend 15–20 minutes evaluating how your past behaviors align with these operating principles.

The hiring process at Remitly combines rigorous practical coding, object-oriented modeling, system architecture, and leadership evaluations. The process moves from initial recruiter alignment through technical phone screens to a multi-stage loop.

       ┌─────────────────────────┐
       │   Recruiter Screen      │
       │   (15 - 30 Minutes)     │
       └────────────┬────────────┘
                    │
                    ▼
       ┌─────────────────────────┐
       │  Technical Screen /     │
       │  Take-Home Assignment   │
       │      (60 Minutes)       │
       └────────────┬────────────┘
                    │
                    ▼
       ┌─────────────────────────┐
       │  Virtual Onsite Loop    │
       │    (4 - 5 Rounds)       │
       └────────────┬────────────┘
                    │
          ┌─────────┴─────────┐
          ▼                   ▼
┌──────────────────┐┌──────────────────┐
│ Coding & OOD     ││ System Design    │
│ (2 Rounds)       ││ (1 Round)        │
└──────────────────┘└──────────────────┘
          │                   │
          └─────────┬─────────┘
                    │
          ┌─────────┴─────────┐
          ▼                   ▼
┌──────────────────┐┌──────────────────┐
│ Past Work Deep   ││ Manager & Culture│
│ Dive / PM Round  ││ Behavioral Round │
└──────────────────┘└──────────────────┘

The visual timeline outlines the typical sequence from recruiter screening through technical evaluations to the comprehensive loop. Most technical rounds follow a hybrid format: approximately 15–20 minutes are dedicated to structured behavioral questions based on company values, followed by 35–40 minutes of practical problem solving or architectural design. Candidates should pace themselves to communicate both their leadership background and their code structure clearly within each session.

`

{`

Object-Oriented & Practical Domain Coding

This area measures your ability to transform realistic business requirements into extensible, production-ready code. Interviewers want to see how you model entities, encapsulate domain logic, and structure interfaces.

Be ready to go over:

• Domain Modeling & Encapsulation – Translating business concepts (e.g., bank accounts, cards, timers, elevators) into clean class structures.
• Defensive Programming & Input Validation – Handling null pointers, illegal arguments, boundary limits, and unexpected stream inputs cleanly.
• Code Maintainability & Testability – Writing code that allows easy unit testing, injection of dependencies, and logical extension.
• Advanced concepts (less common) – Thread-safe concurrency primitives, custom locks, non-blocking stream processing state, and memory-efficient data collections.

Example scenarios:

• Implement an elevator controller system that balances request queues, manages internal floor registrations, and handles directional state transitions cleanly.
• Model a weighted task selection manager that guarantees exact probability distribution when picking arbitrary task objects over time.
• Write a resilient currency stream parser that extracts monetary amounts matching specific ISO currency symbols from an unbuffered input stream.

System Architecture & Distributed Systems

This area evaluates how you architect backend systems that must remain available, performant, and resilient despite network failures, high request volumes, and unreliable dependencies.

Be ready to go over:

• Integration with Unreliable External APIs – Implementing circuit breakers, retry strategies with backoff, fallbacks, and dead-letter queues.
• Scalable Job Scheduling & Polling – Designing distributed worker pools, message queues, and partitioning strategies to sync massive external datasets.
• Data Persistence & Cache Invalidation – Choosing between relational ledgers (e.g., PostgreSQL) and key-value stores (e.g., Redis) based on transaction requirements.
• Advanced concepts (less common) – Distributed transaction orchestration (Saga patterns), event-driven ledger architecture, streaming window aggregations, and idempotent payment processing.

Example scenarios:

• Design a batch polling system to sync appointment schedules from 100,000 distinct merchants every 10 minutes while adhering to external rate limits.
• Architect an internal proxy service that queries an unstable, rate-limited IP reputation API, ensuring sub-hundred-millisecond responses for transaction risk checks.

`

{`

Past Technical Deep Dives & Resume Verification

Senior candidates are thoroughly evaluated on their ability to articulate past engineering decisions, explain system trade-offs, and prove ownership of complex initiatives.

Be ready to go over:

• Architecture Ownership – Walking through end-to-end component diagrams of systems you designed and shipped.
• Trade-Off Analysis – Explaining why specific databases, protocols, or frameworks were chosen over viable alternatives.
• Operational Failure Modes – Detailing real production incidents, post-mortems, root cause analyses, and performance optimizations.
• Advanced concepts (less common) – Cost optimization at scale, cross-region migration strategies, and multi-tenant isolation patterns.

Example scenarios:

• Walk through a complex distributed system you built from scratch, highlighting the single hardest technical trade-off you had to navigate.
• Describe a situation where a service you owned failed in production due to a third-party dependency. How did you resolve the outage and prevent future recurrence?

Leadership, Culture & Core Values

Every interviewer at Remitly assesses culture fit and alignment with core operating values. Candidates must demonstrate accountability, direct communication, and alignment with the customer experience.

Be ready to go over:

• Constructive Directness & Conflict Resolution – Navigating technical disagreements with colleagues or leadership while maintaining trust.
• Customer Empathy & Focus – Translating customer pain points directly into engineering decisions and platform improvements.
• Bias for Action vs. Rigor – Deciding when to ship rapidly versus when to slow down to ensure security, compliance, and financial accuracy.
• Advanced concepts (less common) – Cross-functional collaboration across multi-time-zone teams, cross-cultural team management, and driving technical standards across organizational boundaries.

Example scenarios:

• Describe a project where business requirements changed late in the development cycle. How did you adapt your implementation strategy while maintaining delivery timelines?
• Tell me about a time you identified significant technical debt in a core system. How did you pitch the refactoring initiative to non-technical stakeholders?

As a Software Engineer at Remitly, your work centers on building, maintaining, and scaling the technology platforms that power global remittances.

┌─────────────────────────────────────────────────────────────────────────┐
│                    Software Engineer Core Workstreams                   │
├──────────────────────────┬──────────────────────┬───────────────────────┤
│    Product & Feature     │   Infrastructure &   │ Operational Rigor &   │
│       Engineering        │     Architecture     │    Quality Assurance  │
├──────────────────────────┼──────────────────────┼───────────────────────┤
│ • Design transaction     │ • Build resilient    │ • Maintain high unit  │
│   flows & APIs.          │   polling pipelines. │   & integration test  │
│ • Integrate third-party  │ • Optimize ledger    │   coverage.           │
│   payment processors.    │   storage structures.│ • Participate in on-  │
│ • Build real-time risk   │ • Implement fault-   │   call rotations &    │
│   evaluation services.   │   tolerant queues.   │   incident response.  │
└──────────────────────────┴──────────────────────┴───────────────────────┘

You will collaborate closely with Product Managers, Data Scientists, and Operations teams to define technical roadmaps and implement services capable of handling high transaction volumes.

Engineers spend significant time writing clean code, reviewing pull requests, refining automated integration tests, and maintaining active service operational metrics. You will also participate in on-call engineering rotations, ensuring high availability, sub-second transaction validation, and rapid incident response for critical payment flows.

Candidates are evaluated across a combination of core software engineering fundamentals, distributed systems knowledge, and team collaboration skills.

Technical Qualifications

• Must-Have Skills: Strong proficiency in at least one modern object-oriented or backend language (e.g., Java, Go, Python, C#); solid understanding of core data structures, algorithms, and object-oriented design; practical knowledge of relational databases (SQL) and schema design; experience designing RESTful or gRPC microservices.
• Nice-To-Have Skills: Hands-on experience with cloud infrastructure (AWS/GCP); familiarity with event-driven streaming frameworks (Kafka, Kinesis); experience building financial ledgers, payment processing systems, or high-throughput risk detection pipelines.

Experience & Soft Skills

• Experience Levels: Roles range from SDE I and SDE II to Senior, Staff, and Principal levels depending on overall technical scope, architecture leadership, and professional experience (typically 2+ years for SDE II, 5+ years for Senior/Staff roles).
• Leadership & Communication: Proven track record of framing technical decisions using data, navigating ambiguous requirements, communicating effectively across cross-functional teams, and conducting thorough code reviews.

Q: How do technical interviews at Remitly differ from typical LeetCode-heavy screens? While foundational data structures and algorithms are assessed, Remitly emphasizes practical object-oriented design and real-world domain modeling (e.g., modeling elevators, decks of cards, or bank balance transfers). Writing clean, structured code with thorough edge-case handling is valued over memorizing algorithmic tricks.

Q: How much time should I allocate to behavioral preparation? Every technical round includes 15–20 minutes dedicated to behavioral questions mapped to Remitly's core values. Prepare 4–6 detailed stories using the STAR framework that demonstrate technical leadership, conflict management, customer impact, and operational rigor.

Q: What design tools can I use during the System Design round? You can generally use standard virtual whiteboarding tools such as Excalidraw, Miro, or standard drawing platforms during virtual onsite sessions. Clarify your preferred tool with your interviewer at the beginning of the round.

Q: What programming languages are accepted during live coding rounds? You may use any modern language of your choice, including Java, Go, Python, C++, or C#. It is advisable to select the language in which you are most fluent writing idiomatic, object-oriented, and compilable code under time constraints.

Q: What is the typical timeframe from initial interview screen to final decision? The full process typically takes between 3 to 5 weeks from initial recruiter outreach to final decision, depending on scheduling availability across virtual onsite panel members.

`

{`

• Structure Behavioral Responses Using STAR: Clearly state the Situation, Task, Action, and Result. Keep your focus heavily on the specific Actions you personally took and quantify the Results with business or technical metrics whenever possible.
• Focus on Practical OOP Design Patterns: Ensure you demonstrate clear separation of concerns, single-responsibility principle (SRP), and clean interface definitions when approaching domain design problems like card shufflers or event queues.
• Incorporate Failure Modes Early in Architecture Discussions: When designing backend systems, proactively discuss what happens when dependencies go down, network connections time out, or third-party APIs enforce rate limits.
• Ask Clarifying Questions Before Coding: Resist the urge to write code immediately. Spend the first 3–5 minutes clarifying input constraints, expected output formats, domain edge cases, and performance boundaries.

A Software Engineer role at Remitly offers the opportunity to build mission-critical financial systems that directly affect millions of people across the globe. Success in the interview process requires demonstrating strong object-oriented software engineering skills, pragmatic system design abilities, and alignment with company culture.

Focus your technical preparation on object-oriented domain modeling, practical algorithmic implementation, fault-tolerant distributed system architectures, and concise STAR-formatted behavioral responses. Proactively driving the technical discussion and communicating your trade-offs clearly will set you apart throughout the loop.

To further refine your preparation, access detailed interview experiences, real-world practice prompts, and community interview insights on Dataford.

The compensation data reflects baseline and total earning potential for software engineering roles at Remitly, scaled by level and geographic location. Total compensation typically combines base salary, annual performance bonuses, and equity grants (RSUs). Use these benchmarks during offer negotiations to align expectations based on your targeted level and location.