In a mobile system design interview, design only as much backend as the scope needs. Ask about scope in the first five minutes. Most rounds fall into one of three scopes. You design the app alone. Or you design the app plus its API. Or you add the backend too. The prompt rarely says which one you’re in. When nobody says, assume the app plus the API. Draw the backend as a few boxes. Give each box one sentence about what it promises the app. Then stub the rest out loud, with something like “I’ll assume the server stores messages durably.” One rule overrides the stub. Some logic can’t be trusted to a phone. Ordering, conflict resolution and permission checks belong on the server. Say so even in a client-only round. If the interviewer does want backend depth, describe the properties you need from each part. Skip vendor names you can’t defend. Below, one chat prompt runs through every step, with a full script at the end.
A mobile system design interview comes in three scopes, and the prompt rarely names one
Alex Lementuev’s open-source framework for mobile system design interviews lists the three scopes. The README was last edited in January 2026. In the first, you design the app against a given backend and API. In the second, you design the app and the API. In the third, you add the backend too. Lementuev calls the app-plus-API scope the most common one. He calls the full-stack scope less likely. That’s one experienced author’s view, not a published company rule. His guide also says it doesn’t reflect any company’s interview policy.
ByteByteGo’s undated framework for mobile system design interviews points the same way. ByteByteGo sells interview courses, so read its numbers as coaching. Its five steps put API design second, right after scoping. It budgets five to ten minutes of a 45-minute round for the API. The backend itself never gets its own step.
Company pages say little about this. Meta’s prep post for software engineers was last updated in October 2022. It says the design question focuses on systems or product, depending on your background. So even the round’s name can hide its scope. Ask the recruiter which design round you’ll get. Then ask the interviewer again when the prompt lands.
The running example: a group chat feature for an Android app
Take a common prompt. “Design group chat for our Android app.” The round is 45 minutes. The interviewer says nothing else.
Android candidates tend to miss the backend in one of two ways. The first is to stay entirely inside the app. They draw a Compose screen, a ViewModel, a repository and a Room cache. Then they describe paging and offline reads. The server is a cloud icon labeled “API.” The interviewer still can’t tell how a message gets from one phone to another. They also can’t tell who decides its order.
The second miss is the overcorrection. The candidate hears “system design” and starts on database sharding and message queues. They’ve read about these but never run them. Ten minutes go to the server. Then the interviewer asks a follow-up about the queue. The answers turn thin. Meanwhile offline sends and push delivery, the parts this candidate knows best, never come up.
Both misses come from guessing the scope. One question up front prevents them.
Draw the backend as boxes that each make one promise
Suppose the interviewer says to focus on the app and define the API. That’s Lementuev’s middle scope. The backend now needs boxes. It doesn’t need internals.
For group chat, four boxes are enough. Write one promise beside each.
- Chat service. It accepts a message and returns it with a server sequence number.
- Message store. Messages are durable once the service has acknowledged them.
- Real-time channel. An open app gets new messages within a second or two.
- Push provider. A closed app gets a notification that new messages exist.
Each promise is a fact the app relies on. None of them says how the server keeps it. That’s the stub. You can say it in one line. “I’ll assume the store is durable and the service scales. I’ll spend our time on the app and the contract.” Lementuev’s mistakes guide advises interviewers to allow this kind of stub. A candidate who doesn’t know a backend detail can abstract it away. The interviewer then has more time to test mobile skills.
Then write the contract the boxes imply. Three calls cover the core of the feature.
POST /conversations/{id}/messages
body: { clientId, text }
returns: { clientId, seq, sentAt }
GET /conversations/{id}/messages?afterSeq={n}&limit=50
returns: { messages: [...], nextAfterSeq }
real-time event: { conversationId, seq }
The client creates clientId before it sends. A retry after a dropped response reuses the same ID. So the server can spot a duplicate instead of storing it twice. The afterSeq cursor lets a phone that was offline fetch exactly what it missed.
Some logic has to cross to the server, even in an app-only round
The stub has one limit. A phone is the wrong place to decide anything other users depend on. Lementuev’s guide makes the same point. It warns against putting trusted logic, like conflict resolution or timestamps for ordering, on the client. The reason is that clients are unreliable and their clocks drift.
Chat shows why. Two members send a message in the same second. Each phone stamps its own time. One phone’s clock runs two minutes fast. If the app sorts by those times, the two phones show different conversations. So the server assigns seq. Every client sorts by it. A message still waiting to send gets a temporary spot at the bottom. It moves to its real spot when the server answers.
The same test sorts other choices. Who can post to this group? The server checks that. The app can hide the input box. That’s only a convenience. Did two people rename the group at once? The server decides which rename wins. Each answer takes one sentence. Each one shows you know where the trust line sits. None of them needs a backend design.
If the interviewer wants backend depth, describe the properties you need
Sometimes the answer to your scope question is “the whole thing.” Lementuev’s advice for that case is to be open about limited backend experience. Lean on your mobile expertise, then cover backend concepts at a high level.
In practice, that means naming properties. His mistakes guide gives an example. Don’t guess a specific database. Explain what you need from it instead. For chat, the message store has to support appends per conversation and reads by sequence range. Messages are written once and rarely edited. That points toward a store partitioned by conversation ID. You can say all of that without naming a vendor. Then add one honest line. “I haven’t run a store like this at scale. I’d want to check how it handles one very large group.”
That line is a calibration signal. An interviewer can push on a property and get a reasoned answer. A product name you can’t defend invites the follow-up you can’t answer. Then go back to the app, where your depth is.
A sample script for the group chat prompt
Here’s the whole approach as you might say it across the first 15 minutes. Swap in your own prompt.
Before I design anything, one scope question. Should I design only the Android app, the app plus the API, or the backend too? Okay, app plus API. I’ll treat the server as a few services with clear promises.
On the server side I’ll draw four boxes. The chat service accepts a message and gives it a sequence number. The store keeps acknowledged messages durably. A real-time channel delivers to open apps. Push notifies closed ones. I’ll assume they scale, unless you’d like me to go inside one.
One thing I’ll keep on the server even though I’m focused on the app. Message order comes from the server’s sequence number, not the phone’s clock. Phone clocks drift, so two members could see different orders. The same goes for who can post. The app hides the input. The server enforces the rule.
Here’s the contract. Sending takes a client-generated ID, so a retry can’t create a duplicate. Fetching takes an after-sequence cursor, so a phone coming back online gets exactly what it missed.
Now the app. Unsent messages go into a local outbox first and show at the bottom as pending. I’d like to go deep on the outbox and on offline catch-up. That’s where chat apps usually break. Does that match what you want to cover?
The first line settles the scope before any box appears. The four boxes with promises give the interviewer a complete picture in under a minute. “Unless you’d like me to go inside one” invites a deeper backend question instead of hiding from it. The trust paragraph is the one piece of backend reasoning an app-only round still needs. The contract turns the promises into fields the app depends on. The last line steers the deep dive toward your strongest ground. It still lets the interviewer pick.
Practice the scope question on three versions of one prompt
Pick one prompt, like group chat or a photo feed. Answer it three times, once per scope, with a 15-minute timer each.
- App only. Write the trust line as a list of decisions the server owns.
- App plus API. Add the boxes, their promises and three calls.
- Full stack. Pick one box and describe its properties without naming a vendor.
Compare the three versions. The trust line should be the same in all of them. If it changes, you’re deciding trust based on how much time you have. An interviewer will notice. Meta’s product architecture round asks a related question. See our post on the Meta product architecture interview. For keeping the deep dive on schedule, see running out of time in a system design interview. Our post on offline sync duplicates after a retry goes deeper on the client ID.