As a Software Engineer at We Are Apt, you are not just writing code; you are contributing to high-performance systems that demand rigorous technical precision. The role is centered on solving complex problems that require a deep understanding of computer science fundamentals, particularly within the C++ ecosystem. You will be expected to produce clean, maintainable, and efficient code that stands up to intense scrutiny. This position is critical to the company because We Are Apt prioritizes technical depth and performance in its engineering culture. You will work on challenging technical tasks that range from architectural design to low-level systems programming. Successful engineers here are those who possess a strong grasp of Operating Systems, Networking, and Memory Management, and who are capable of translating these theoretical concepts into robust, real-world solutions. Candidates should interpret these figures as a starting point for negotiations, keeping in mind that total compensation packages at We Are Apt often include performance-based incentives and benefits that reflect the high level of technical proficiency required. Use this data to calibrate your expectations while focusing on demonstrating your unique value proposition to the hiring team.
Online Assessment
reportedInitial assessment to filter candidates based on technical proficiency.
What to demonstrate
- Initial assessment to filter candidates based on technical proficiency
- Depth in C++
How to prepare
- Answer aloud and timed: Explain the difference between heap and stack memory allocation.
- Answer aloud and timed: How do smart pointers improve memory safety in C++?
Technical Interviews
reportedMultiple rounds of technical interviews focusing on past projects and core computer science fundamentals.
What to demonstrate
- Multiple rounds of technical interviews focusing on past projects and core computer science fundamentals
- Depth in C++
How to prepare
- Answer aloud and timed: Discuss the concept of cache coherence and its impact on performance.
- Answer aloud and timed: How do you manage process synchronization in a multi-threaded environment?
PracHub editorial advice for the preparation topics above.
Going into the loop without having done this.
Own your resume: Be prepared to discuss every line of your project experience in extreme detail. If you list a technology, expect to be asked how it works under the hood.
Going into the loop without having done this.
Think aloud: Your interviewer wants to see your thought process. Even if you are stuck, verbalizing your reasoning helps the interviewer evaluate your problem-solving approach.
Going into the loop without having done this.
Prioritize fundamentals: Do not neglect your OS and Networking basics; they are as important as your coding ability.
Going into the loop without having done this.
Practice clean code: Avoid "hacky" solutions. Write your code as if it were going into a production codebase tomorrow.
Choose a category, try a prompt, then open its approach, worked solution or follow-up when you need it.
Explain the difference between heap and stack memory allocation.
Explain the difference between heap and stack memory allocation.
Approach
- Say what the runtime actually does before reasoning about the code.
- Name what is shared across threads and what owns each piece of state.
- Identify the window where an invariant is briefly untrue.
- Distinguish a value from a reference to it, and say which one you handed out.
Follow-up
- What happens if two callers reach this at the same time?
- Where could this allocate more than you expect?
How do smart pointers improve memory safety in C++?
How do smart pointers improve memory safety in C++?
Approach
- Say what the runtime actually does before reasoning about the code.
- Name what is shared across threads and what owns each piece of state.
- Identify the window where an invariant is briefly untrue.
- Distinguish a value from a reference to it, and say which one you handed out.
Follow-up
- What happens if two callers reach this at the same time?
- Where could this allocate more than you expect?
Discuss the concept of cache coherence and its impact on performance.
Discuss the concept of cache coherence and its impact on performance.
Approach
- Say what the runtime actually does before reasoning about the code.
- Name what is shared across threads and what owns each piece of state.
- Identify the window where an invariant is briefly untrue.
- Distinguish a value from a reference to it, and say which one you handed out.
Follow-up
- What happens if two callers reach this at the same time?
- Where could this allocate more than you expect?
How do you manage process synchronization in a multi-threaded environment?
How do you manage process synchronization in a multi-threaded environment?
Approach
- Say what the runtime actually does before reasoning about the code.
- Name what is shared across threads and what owns each piece of state.
- Identify the window where an invariant is briefly untrue.
- Distinguish a value from a reference to it, and say which one you handed out.
Follow-up
- What happens if two callers reach this at the same time?
- Where could this allocate more than you expect?
Explain the difference between thread-local and process-local address spaces.
Explain the difference between thread-local and process-local address spaces.
Approach
- Say what the runtime actually does before reasoning about the code.
- Name what is shared across threads and what owns each piece of state.
- Identify the window where an invariant is briefly untrue.
- Distinguish a value from a reference to it, and say which one you handed out.
Follow-up
- What happens if two callers reach this at the same time?
- Where could this allocate more than you expect?
How would you implement a specific graph traversal algorithm under time constraints?
How would you implement a specific graph traversal algorithm under time constraints?
Approach
- Restate the input: its shape, its size, and what is guaranteed about it.
- Name the brute-force solution and its complexity before improving on it.
- Choose the data structure from the access pattern, not from familiarity.
- State the target complexity and say which constraint rules the naive version out.
Follow-up
- How does this change if the input no longer fits in memory?
- What is the worst case, and how likely is it on real data?
Solve a medium-to-hard complexity problem involving dynamic data structures.
Solve a medium-to-hard complexity problem involving dynamic data structures.
Approach
- Restate the input: its shape, its size, and what is guaranteed about it.
- Name the brute-force solution and its complexity before improving on it.
- Choose the data structure from the access pattern, not from familiarity.
- State the target complexity and say which constraint rules the naive version out.
Follow-up
- How does this change if the input no longer fits in memory?
- What is the worst case, and how likely is it on real data?
Describe the trade-offs between different sorting algorithms in a performance-critical context.
Describe the trade-offs between different sorting algorithms in a performance-critical context.
Approach
- Restate the input: its shape, its size, and what is guaranteed about it.
- Name the brute-force solution and its complexity before improving on it.
- Choose the data structure from the access pattern, not from familiarity.
- State the target complexity and say which constraint rules the naive version out.
Follow-up
- How does this change if the input no longer fits in memory?
- What is the worst case, and how likely is it on real data?
How do you optimize an algorithm that is hitting memory bottlenecks?
How do you optimize an algorithm that is hitting memory bottlenecks?
Approach
- Say what the runtime actually does before reasoning about the code.
- Name what is shared across threads and what owns each piece of state.
- Identify the window where an invariant is briefly untrue.
- Distinguish a value from a reference to it, and say which one you handed out.
Follow-up
- What happens if two callers reach this at the same time?
- Where could this allocate more than you expect?
Find version gaps and relay lag with window functions
outbox_event holds event_id, aggregate_type, aggregate_id, aggregate_version, event_type, payload, status ('pending','published','dead'), attempts, created_at, published_at. A projection is missing rows and you must decide whether the relay skipped events or the consumer dropped them. Write three queries over the last seven days: one listing every aggregate_id whose published aggregate_version sequence has a hole, one giving per-day counts with a running total, and one returning the newest published event per aggregate. For each, say where the window function is evaluated relative to WHERE and LIMIT. PostgreSQL 16.
Approach
- Gaps: compute lead(aggregate_version) OVER (PARTITION BY aggregate_id ORDER BY aggregate_version) in a subquery, then filter next_version <> aggregate_version + 1 in the outer query. Window functions are evaluated after WHERE, GROUP BY and HAVING and before the outer ORDER BY and LIMIT, so the predicate cannot sit in the same WHERE clause and PostgreSQL 16 has no QUALIFY.
- Say what the seven-day filter does to the answer: it truncates every partition, so the first row per aggregate has no predecessor inside the window and a hole spanning the boundary is invisible. Widen the window, or join to resource.version as the authority for the true maximum.
- Running total: SELECT date_trunc('day', created_at) AS d, count() AS n, sum(count()) OVER (ORDER BY date_trunc('day', created_at) ROWS UNBOUNDED PRECEDING). An aggregate inside a window call is legal because grouping runs before windowing. The grouping key is unique per row here so ROWS and RANGE agree, but write the frame anyway — over ungrouped rows with tied timestamps the default RANGE frame pulls in every peer row and the total jumps.
- Newest per aggregate: DISTINCT ON (aggregate_id) ... ORDER BY aggregate_id, aggregate_version DESC is the cheap PostgreSQL-only form when an index matches that order; row_number() OVER (PARTITION BY aggregate_id ORDER BY aggregate_version DESC) = 1 is the portable form and needs a subquery for the same evaluation-order reason as the gap query.
Follow-up
- Relay failover redelivers events. Does a duplicate break the gap query, and how would you detect one from this table alone?
- Turn the gap check into a continuous monitor rather than a query someone runs after an incident. What does it watch?
Replace offset paging on the resource feed with keyset
resource holds resource_id, tenant_id, owner_user_id, title, body_ref, version, status ('draft','active','archived','deleted'), created_at, updated_at, deleted_at, with an index on (tenant_id, status, updated_at DESC, resource_id DESC). The listing endpoint returns active resources for one tenant, newest update first, 50 per page, today with LIMIT 50 OFFSET n. Tenants reach page 400 and rows are created while they read. Write the keyset query, define what the cursor carries and how it is encoded, and say which part of the index each predicate uses. Assume PostgreSQL 16.
Approach
- Name the two failures separately. OFFSET 20000 makes the server produce and discard 20,000 rows, so page cost grows with depth rather than with page size. Independently, any write that changes how many rows sort above the offset moves the window between two fetches, and the direction decides which anomaly you get: an insert lands at the head of updated_at DESC and pushes already-returned rows down past the boundary, so they are returned a second time; a delete above the offset, or a row whose updated_at is bumped above the cursor, pulls rows up and one is never returned at all. Nothing in the response reveals either.
- Write the seek: WHERE tenant_id = $1 AND status = 'active' AND (updated_at, resource_id) < ($2, $3) ORDER BY updated_at DESC, resource_id DESC LIMIT 50. The row-value comparison is one index range rather than a disjunction, and both columns are NOT NULL, which is what makes that comparison well defined.
- Map each predicate onto the index: tenant_id and status are equality on the leading columns, (updated_at, resource_id) is the range, and the ORDER BY matches the index order so no Sort node appears and the scan stops after 50 rows. The DESC in the definition only matters for mixed directions — a plain ascending btree on the same columns is read backwards for this query.
- Put both sort columns in the cursor and nothing the client can tamper with into another tenant: base64 of (updated_at, resource_id), validated server-side, with tenant_id taken from the principal.
Follow-up
- The client asks for 'jump to page 400'. What do you offer instead, and what does the honest version cost?
- Sort order becomes user-selectable across four columns. How many indexes is that, and which would you refuse to add?
Publish rate-limit and deadline semantics the edge actually enforces
The edge API serves about 3k requests/second steady and 9k at peak against a 400 ms p99 budget, with an explicit bounded concurrency limit per instance. Limits exist per principal and per tenant. Callers are a partner integration running nightly bulk loads and a browser app. Specify the counting algorithm and window, which limit a request is charged against, the headers a well-behaved client reads, the status and body when a limit is hit, how that differs from the response when an instance is shedding load, and what each caller does with each.
Approach
- Choose the counter and name its failure mode. Fixed windows admit nearly twice the limit across a boundary - a full burst at the end of one window and another at the start of the next. A token bucket states sustained rate and burst separately, which is exactly what a nightly bulk load needs. A sliding-window counter is more faithful and costs more state per key. State the choice and the burst it permits.
- Charge each request against both keys and reject on the stricter. The tenant limit protects the shared primary, which absorbs roughly 1.2k writes/second in total; the per-principal limit stops one credential inside a tenant from consuming that tenant's whole allowance. The tenant is the fairness unit for the same reason it is the leading column of every index.
- Advertise limit, remaining and reset for the binding key on every response, not only on rejections, so a client can pace before it is refused. Pick one naming scheme - the RateLimit-* draft fields or an X-prefixed set - document the units, and never change them afterwards.
- Separate two rejections that look identical to a naive client. 429 means this caller exceeded its own share and Retry-After is a real schedule it should obey. 503 means the instance is at its concurrency bound and shedding, which is a statement about the server; a fleet-wide 503 retried on a fixed delay resynchronises every client into one stampede, so full jitter is mandatory there and the delay is the client's guess, not ours.
Follow-up
- One tenant stays under its limit and still degrades everyone else during a backfill. What changes - the limiter, the worker concurrency caps, or both?
- How are counters kept correct across 20 to 40 stateless instances, and what does your answer cost per request?
Cache the tenant listing feed with a bounded staleness window
GET /v1/resources returns one tenant's resources ordered by updated_at DESC, 20 per page, at 14k requests/second peak against a 120 ms p99. The table carries the index (tenant_id, status, updated_at DESC, resource_id DESC) and writes land on the primary at 1.2k/second. Design the read path: the pagination contract, the cache key and value, what a write invalidates, and the staleness a user can observe. State the request rate that actually reaches the database, and the one repopulation race that deleting on write does not close.
Approach
- Settle the pagination contract first, because it decides what is cacheable. OFFSET makes the database produce and discard the skipped rows, so page 500 costs five hundred pages of work, and rows inserted between two fetches shift across the boundary and are skipped or repeated with nothing in the response to reveal it. The cursor is the row value of the last row returned: WHERE tenant_id = $1 AND status = $2 AND (updated_at, resource_id) < ($3, $4) ORDER BY updated_at DESC, resource_id DESC LIMIT 21. That is a row-value comparison, not updated_at < $3 AND resource_id < $4, which is a different and wrong predicate.
- Confirm the index actually serves it: equality on the two leading columns, then a range on the pair that follows in exactly the index's sort order, so the plan is an index scan that touches 21 entries with no sort node. Requesting 21 to return 20 is how has_more is answered without a count. resource_id is not decoration - updated_at is not unique, and without the tie-break two rows sharing a timestamp at a page boundary are the skip that keyset pagination was adopted to remove.
- Key the cache on every value the predicate reads: tenant_id, status, cursor and page size. A key that omits tenant_id is a cross-tenant disclosure, and no test running against a single tenant's data will show it.
- Be honest that a write does not invalidate one key. An update moves its row to the head of the ordering, so it invalidates the first page and every cursor page whose range spans the row's old and new position, which is not enumerable. Cache the first page per (tenant_id, status) - that is where the traffic is - with a short TTL, invalidate it on write, and serve deep cursor pages uncached from a replica, since each is already a 21-row index scan and they are rare.
Follow-up
- The tenant writes and immediately lists. What does it see, and what is the smallest change that makes its own write visible without sending all 14k requests/second to the primary?
- A tenant has 4 million resources and a client walks every page nightly. What does that do to the cache hit rate, and should that traffic share this path at all?
How do you approach debugging a system that shows intermittent performance degradation?
How do you approach debugging a system that shows intermittent performance degradation?
Approach
- Establish what changed and when, before forming any theory.
- Pick a bisection that eliminates candidates whichever way it turns out.
- Check the instrumentation before believing the symptom.
- Separate the trigger from the cause; the deploy is rarely the bug.
Follow-up
- What would you look at first, and what would it rule out?
- How would you tell a cause from a coincidence here?
Built from the rounds and topics We Are Apt candidates report.
Prepare, practise & reflect
One practical outcome each day. Spend longer where you need it.
0 / 7 done01Map the We Are Apt loop
- Write out the reported sequence: Online Assessment, Technical Interviews.
- For each round, write one sentence on what it is judging, from the description above, and mark the one you are least ready for.
Deliverable: A one-page map of the 2 reported rounds, with the weakest marked.
02Work C++
- Spend the session on C++, which We Are Apt candidates report being tested on.
- Write one worked example in C++ and time yourself on it.
Deliverable: One timed worked example in C++.
03Work Data Structures & Algorithms (DSA)
- Spend the session on Data Structures & Algorithms (DSA), which We Are Apt candidates report being tested on.
- Write one worked example in Data Structures & Algorithms (DSA) and time yourself on it.
Deliverable: One timed worked example in Data Structures & Algorithms (DSA).
04Work C++ Smart Pointers
- Spend the session on C++ Smart Pointers, which We Are Apt candidates report being tested on.
- Write one worked example in C++ Smart Pointers and time yourself on it.
Deliverable: One timed worked example in C++ Smart Pointers.
05Answer out loud: C++ Fundamentals and Systems Programming
- Answer aloud, timed: Explain the difference between heap and stack memory allocation.
- Answer aloud, timed: How do smart pointers improve memory safety in C++?
Deliverable: Spoken answers to 2 reported C++ Fundamentals and Systems Programming question(s), under time.
06Answer out loud: Data Structures and Algorithms
- Answer aloud, timed: How would you implement a specific graph traversal algorithm under time constraints?
- Answer aloud, timed: Solve a medium-to-hard complexity problem involving dynamic data structures.
Deliverable: Spoken answers to 2 reported Data Structures and Algorithms question(s), under time.
07Answer out loud: Behavioral and Project Discussion
- Answer aloud, timed: Walk me through a complex project from your resume and the specific technical challenges you faced.
- Answer aloud, timed: Why are you interested in joining We Are Apt?
Deliverable: Spoken answers to 2 reported Behavioral and Project Discussion question(s), under time.
Expand any day for tasks and deliverables. Your progress is saved on this device.
Behavioural rounds judge the decision you made and what it cost.
Walk me through a complex project from your resume and the specific technical challenges you faced.
Walk me through a complex project from your resume and the specific technical challenges you faced.
Approach
- Pick a story where you made the decision, not one where you watched it.
- State the situation in two sentences and spend the rest on the reasoning.
- Give the blast radius: what could have broken, and what you measured.
- Name the disagreement and how you resolved it with evidence.
Follow-up
- What would you do differently if you ran that again?
- How did you know your change caused the improvement?
Why are you interested in joining We Are Apt?
Why are you interested in joining We Are Apt?
Approach
- Pick a story where you made the decision, not one where you watched it.
- State the situation in two sentences and spend the rest on the reasoning.
- Give the blast radius: what could have broken, and what you measured.
- Name the disagreement and how you resolved it with evidence.
Follow-up
- What would you do differently if you ran that again?
- How did you know your change caused the improvement?
Narrate an outage you owned from page to postmortem
Pick an incident you personally drove, ideally one where writes were affected rather than reads. In six to eight minutes: state the symptom as it first appeared on a dashboard, the blast radius you established before you knew the cause, the mitigation you applied and when, the mechanism you eventually proved, and the follow-up that would prevent a repeat. Bring numbers: error rate, tenants affected, minutes to mitigate, minutes to resolve. If you cannot name what you measured, choose a different incident.
Approach
- Open on the signal rather than the cause: which metric at which percentile moved, on which service, at what time, so the listener follows the same evidence you had rather than a conclusion you already reached.
- Separate mitigation from diagnosis out loud. State what you did to stop the bleeding (flag off, shed traffic, drain a lease, roll back a deploy) and say plainly that you did it before the mechanism was known, because those are two jobs with different deadlines.
- Establish blast radius in countable terms: how many tenants, how many writes, and crucially whether the effect was loss or only delay. An append-only revision table or a pending outbox row means the change survived and the projection was merely behind, which is a repair rather than a data-loss incident.
- Prove the mechanism instead of asserting it. Name the trace span that grew, the plan that flipped to a sequential scan, the lease that expired, plus one alternative you ruled out and the signal that stayed flat while you ruled it out.
Follow-up
- What would you do differently in the first five minutes, given the same dashboard and no more information?
- Which follow-up action did you deliberately not take, and why was dropping it the right call?
- 01
Walk me through a complex project from your resume and the specific technical challenges you faced.
- 02
Why are you interested in joining We Are Apt?
- 03
Pick an incident you personally drove, ideally one where writes were affected rather than reads. In six to eight minutes: state the symptom as it first appeared on a dashboard, the blast radius you established before you knew the cause, the mitigation you applied and when, the mechanism you eventually proved, and the follow-up that would prevent a repeat. Bring numbers: error rate, tenants affected, minutes to mitigate, minutes to resolve. If you cannot name what you measured, choose a different incident.
How much time should I spend preparing?
Given the technical difficulty, we recommend at least 4–6 weeks of dedicated study, focusing specifically on C++ internals and OS concepts.
We Are Apt Software Engineer candidate reports ↗What differentiates successful candidates?
Successful candidates don't just solve the problem; they demonstrate a deep understanding of the trade-offs involved in their solution, such as memory usage vs. execution speed.
We Are Apt Software Engineer candidate reports ↗Is the interview process strictly remote?
While many interviews are conducted online, the process is highly structured and requires a stable environment. Ensure you have a reliable setup for both coding and video conferencing.
We Are Apt Software Engineer candidate reports ↗How is the culture at We Are Apt?
The culture is high-intensity and performance-oriented. We value engineers who are self-starters and thrive on solving intellectually challenging problems.
We Are Apt Software Engineer candidate reports ↗How hard is the We Are Apt interview?
Candidates most commonly rate We Are Apt interviews as medium, based on 22 reported interviews.
We Are Apt Software Engineer candidate reports ↗What topics does We Are Apt test in interviews?
We Are Apt interviews most often cover Problem Solving, Python, Data Structures & Algorithms (DSA), C++, and Coding Interviews. The exact emphasis depends on the specific role you apply for.
We Are Apt Software Engineer candidate reports ↗Where is We Are Apt headquartered?
We Are Apt is headquartered in New Delhi, India.
We Are Apt Software Engineer candidate reports ↗Sources & methodology 3 sources ↗
No official company page is cited. Rounds and questions come from candidate reports and PracHub editorial material; each source shows the date it was read.
- 01We Are Apt Software Engineer candidate reports ↗
Company-reported rounds, questions and FAQ.
Candidate reports · Accessed 2026-09-22 - 02PracHub Software Engineer practice ↗
PracHub practice material, not company-reported.
PracHub page · Accessed 2026-09-22 - 03PracHub preparation framework ↗
PracHub preparation guidance.
PracHub page · Accessed 2026-09-22
Explore related engineering environments and compare the preparation focus.
Cognition Software Engineer Interview Guide
What Cognition asks Software Engineer candidates, from reported rounds and questions.
Discord Software Engineer Interview Guide
Database practice for Discord candidates: how an index changes a query plan, and which anomalies survive a given isolation level, since read committed still permits non-repeatable reads.
CoreWeave Software Engineer Interview Guide
Failure-handling practice for CoreWeave software engineer candidates: requests whose outcome a timeout leaves unknown, where a retry is safe, and deduplicating at the receiver instead of assuming exactly-once delivery.
Aerospike Software Engineer Interview Questions & Guide 2026
Aerospike database-engine preparation through an original single-owner Python key-value store with bounded logical index accounting, disk-offset reads, conditional writes, tombstones, process-restart recovery and 3,240 checks. Existing 14 p