Netflix Entry-Level Mobile Developer Interview Preparation Guide

Approach (brief)
Serialize a tree of navigation entries (activity -> back stack -> nested fragments) where each node has a stable id, type, and map of simple view states. Use kotlinx.serialization to produce a compact JSON and include a schema version. Restoration traverses JSON and applies states where matching ids exist; ignore unknown/missing fields to be forward/backward compatible. Work in O(n) where n = number of UI elements by single-pass traversal/serialization.

Signatures

data class UiNode(
  val id: String,
  val type: String,
  val children: List<UiNode> = emptyList(),
  val viewState: Map<String, Any> = emptyMap()
)

object NavigationStateSerializer {
  fun serialize(root: UiNode, version: Int = 1): String
  fun restore(json: String, applyState: (UiNode) -> Unit)
}

Code outline

// Use kotlinx.serialization with a polymorphic wrapper for view values (String/Int/Boolean)
@Serializable
data class UiNodeDto(val id: String, val type: String, val children: List<UiNodeDto>, val viewState: Map<String, JsonElement>)

fun NavigationStateSerializer.serialize(root: UiNode, version: Int = 1): String {
  // BFS/DFS single-pass convert UiNode -> UiNodeDto, convert simple values to JsonPrimitives
  // wrap with {"version":version,"root":...}
}

fun NavigationStateSerializer.restore(json: String, applyState: (UiNode) -> Unit) {
  // parse JSON defensively, check version, traverse dto tree
  // for each dto, build UiNode-like minimal object and call applyState(node)
  // applyState should find real UI element by id and set fields (text, selectedIndex) safely
}

Key concepts & guarantees

• Stable ids required for matching; nested structure preserved.
• Graceful handling: unknown keys ignored; missing keys leave defaults.
• O(n): each node visited once in serialize and once in restore.
• Edge cases: malformed JSON (try/catch), unsupported version (best-effort), non-serializable view values filtered.
• Alternative: use ProtoBuf for smaller payloads if binary storage desired.

Direct answer

Keep a stalled dependency peer-to-peer as long as direct conversation is still making progress. Escalate when you hit a concrete trigger: a scope change that neither side can unilaterally absorb, genuinely conflicting priorities that only someone with visibility into both roadmaps can arbitrate, or a hard deadline-driven blocker where peer-to-peer conversation has already stalled.

Framework

Default: work it peer-to-peer. Most stalls are under-communication or unclear ownership, and a direct conversation or a short written proposal usually unsticks them without anyone else getting involved.

Concrete triggers to escalate.

• Scope change: the fix now requires work neither team budgeted for, and only a manager can reprioritize that.
• Conflicting priorities: both sides are acting rationally from their own team's goals, and the trade-off needs someone with visibility into both roadmaps to arbitrate.
• Hard blocker with a deadline: a fixed external date is genuinely at risk, and peer-to-peer conversation has already stalled past a reasonable window, for example no movement after two direct attempts over several days.
• Repeated pattern: the same kind of stall keeps recurring with the same team, which means the real issue is the working relationship or process, not this one dependency.

What to bring when you escalate. A short brief: what's blocked, what you've already tried peer-to-peer, the realistic options and their trade-offs, and the specific decision you need.

Worked example (applying the criteria)

Situation: your team's deliverable needs a schema change from another team that they've deprioritized for two weeks despite two direct requests.
Applying the criteria: this isn't just a communication gap, direct conversation was already tried twice with no movement. It's a conflicting-priorities case, the other team's roadmap has no room for this without reprioritizing something else, combined with a hard blocker, a fixed external deadline in three weeks that this schema change sits on the critical path for (meaning if this dependency slips, the final deadline slips by the same amount, unlike a dependency with buffer to absorb delay).
Action: escalated to the shared manager with a one-page brief covering what's blocked, the two peer-to-peer attempts and their outcome, and two options: the other team reprioritizes one sprint of work, or your team ships a temporary workaround with known limitations, along with the deadline risk if neither happens within the week.
Result: the shared manager reprioritized one sprint item, unblocking the schema change with two weeks to spare before the deadline. Both teams also agreed to flag scope-affecting asks earlier next time, so the same dependency doesn't reach this point again.

Trade-offs and pitfalls

• Escalating too early over normal friction burns trust and reads as an inability to work horizontally.
• Escalating too late, repeatedly trying peer-to-peer past the point it's actually working, puts the deadline at real risk and looks like poor judgment in hindsight.
• A vague escalation with no options and no specific ask wastes the leader's time compared with a brief that names the decision needed.

High-level architecture

• Core modules: Network layer (HTTP client + retry/backoff), Persistence layer (offline cache + conflict resolver), Crypto layer (encryption at rest), Storage adapter (pluggable Keychain/Keystore), Telemetry/Logging, Public API facade.
• Cross-platform core in Kotlin Multiplatform / C++ shared core; thin platform bindings (Swift/Kotlin/JS) for platform integration and native secure storage.

Public APIs (examples)

• init(config: SDKConfig)
• get(resource: Request): Promise<Response>
• post(resource, body, options): Promise<Response>
• enqueue(request, options): RequestHandle // returns immediately, queued
• syncNow(): Promise<SyncResult>
• setConflictResolver(resolver: ConflictResolver)
• setTelemetryHook(hook: TelemetryHook)
• shutdown()

Design API to be immutable/config-driven and backward compatible: add new optional params via options objects; avoid breaking changes.

Offline cache & conflict handling

• Write-through cache for reads; writes enqueue and update a local optimistic state.
• ConflictResolver interface: merge(local, remote, base) -> resolved
• Default: last-writer-wins with timestamp; allow app-provided resolver for domain logic.

Request queueing & retry

• Durable queue persisted on disk; worker thread(s) process FIFO/priority with exponential backoff + jitter; retry policies configurable per-request.
• Supports background sync via platform background APIs (WorkManager / BGTask).

Pluggable secure storage & encryption

• Storage adapter interface with built-in Keychain/Keystore implementations; developer can supply custom adapter.
• All persisted cache encrypted using AES-GCM; keys stored in secure storage; support hardware-backed keys where available.

Threading model

• Single shared background executor for IO and network tasks; main-thread callbacks for API responses.
• Use coroutines (Kotlin)/DispatchQueues (iOS) for cancellable, suspendable operations; ensure non-blocking public API.

Versioning strategy

• Semantic versioning for SDK; strict backward compatibility guarantee for minor/patch. Major version bump for breaking API changes.
• Feature flags and deprecation window: mark APIs deprecated for two minor versions with runtime warnings; provide migration guides and automated codemods for Swift/Kotlin.

Telemetry

• Expose hooks for events (request, retry, conflict, sync); allow opt-in data collection and redaction; sample rate configurable.

This design prioritizes security, cross-platform code reuse, and extensibility while keeping public APIs stable for mobile apps.

I’d test accessibility at three levels: semantic checks, interaction checks, and real screen-reader verification.

What I can automate:

• Every interactive element has a meaningful label, hint, or content description.
• Focusable elements are exposed in a sensible order.
• Buttons and controls have the right traits and are large enough to tap.
• State changes are announced or at least reflected in accessible text.
• Accessibility scanners can catch obvious issues like missing labels or low-contrast text.

What still needs manual review:

• Whether VoiceOver or TalkBack reads the screen naturally.
• Whether the focus order matches the visual and task flow.
• Whether dynamic updates, modal dialogs, and errors are announced at the right time.
• Whether the feature is usable with only the screen reader, no sighted assistance.

I’d build the automated checks into CI and include accessibility in the definition of done, but I’d still do at least one manual pass on a real device before release. Automation finds regressions; humans catch usability problems.

Overview
Below are primary client-side storage options on iOS and Android with use cases, durability, performance, size and security trade‑offs, plus decision criteria.

UserDefaults / SharedPreferences

• Typical use: small app settings, flags, lightweight preferences.
• Durability: persisted to disk; survives restarts and backups (may be cleared on uninstall).
• Performance: very fast for small payloads; synchronous API can block UI if abused.
• Size: intended for < few KB; not for large blobs.
• Security: plaintext; use keychain/keystore for secrets.

NSCache / In-memory cache

• Typical use: transient in-memory caches (images, computed data).
• Durability: not durable; can be evicted anytime (memory pressure).
• Performance: fastest (RAM).
• Size: limited by memory and system eviction.
• Security: in-memory only; still accessible if device compromised.

File storage (Documents/Files / internal storage)

• Typical use: larger blobs, downloaded files, logs, exported data.
• Durability: persistent, included/excluded from backups depending on location.
• Performance: depends on file size and I/O patterns; use streaming for large files.
• Size: limited by device storage; consider quotas.
• Security: plaintext unless encrypted; use file protection APIs (iOS) or encrypted file APIs.

SQLite / Core Data / Room

• Typical use: structured relational data, complex queries, indexing.
• Durability: durable on disk, transactional.
• Performance: good for structured queries; indexing improves reads; writes can block without background threading.
• Size: scales to many MBs/GBs as device permits.
• Security: plaintext DB by default; can use SQLCipher or platform file encryption.

Core Data (Apple) specifics

• Higher-level ORM, object graph, change tracking; good for complex models and performance tuning.

Realm

• Typical use: reactive, object-oriented local DB with simpler APIs.
• Durability: durable, ACID.
• Performance: high read/write performance, built for mobile.
• Size: similar to SQLite; depends on data.
• Security: supports encryption; must manage keys securely.

Keychain / Keystore

• Typical use: small secrets, tokens, credentials.
• Durability: persistent and survives app reinstalls if properly configured; protected by device security.
• Performance: slower (secure enclave access), designed for small items.
• Size: small items (credentials, keys).
• Security: highest on device; hardware-backed where available.

Decision criteria

• Secrets → Keychain/Keystore.
• Tiny config/flags → UserDefaults/SharedPreferences.
• Transient cache → NSCache / in-memory.
• Structured relational data/complex queries → SQLite/Room/Core Data.
• Object-oriented, reactive DB → Realm.
• Large files/blobs → File storage (consider streaming, encryption).
• Need encryption/compliance → use encryption at rest (SQLCipher/File encryption) + secure key storage in Keychain/Keystore.
• Consider performance: prefer in-memory for hot reads, asynchronous DB I/O for writes, index DBs for queries.

Choose by data size, access patterns (read-heavy vs write-heavy), durability needs, security/compliance, and complexity of queries/relationships.

Clarify goals
Prevent UI jank, avoid memory leaks, and be battery efficient while streaming large media and doing background processing on iOS and Android.

High-level architecture

• Separate layers: UI thread (main) → Playback & rendering pipeline (media APIs) → Worker pool for network/IO & CPU tasks → Disk-backed segmented cache → Scheduler (platform background APIs).
• Use platform media players (AVPlayer/ExoPlayer) for efficient decoding; do heavy parsing/analysis off-main.

Thread-pool sizing

• CPU-bound tasks: thread count = max(1, cores - 1) to keep main responsive.
• I/O-bound tasks (network, disk): thread count = min( 2 * cores, 16 ). Use async IO where possible (URLSession/OkHttp async, Kotlin coroutines with Dispatcher.IO).
• Use separate pools for short-lived tasks vs long-running jobs to avoid starvation.

Scheduling background work

• iOS: BGProcessingTask / BGAppRefresh for deferred processing; register tasks with identifiers, request expiration handlers and respect background time. Use background URLSession for uploads/downloads.
• Android: WorkManager with constraints (NetworkType.UNMETERED, BatteryNotLow). Use setExpedited for urgent short work; use foreground service with notification for long streams.

Lifecycle-aware cancellation

• Android: tie coroutines to LifecycleScope/ViewModelScope; cancel jobs in onCleared/onStop as appropriate. Use WorkManager cancellation APIs for scheduled work.
• iOS: use Combine/async-await Tasks tied to view controllers or use OperationQueue with Operation.isCancelled checks; cancel BG tasks on expiration and when UI no longer needs results.
• Always check cancellation points inside heavy loops and release references.

Segmenting large buffers

• Stream into fixed-size segments (e.g., 256KB–2MB) to avoid large contiguous allocations.
• Use pooled ByteBuffer / Data buffers with reuse; on Android use ByteBuffer pool, on iOS reuse Data via NSMutableData or use mmap for disk-backed segments.
• Keep only needed segments in memory; load ahead minimally (adaptive prefetch based on playback rate and network).

Cache & eviction strategy

• Disk-first cache with index + segment files; in-memory LRU for hot segments.
• Eviction: size-based + age-based + access-frequency (LRU with TTL). E.g., memory cap = X MB (per-device class), disk cap = Y GB.
• Persist metadata to quickly reconstruct cache on restart.
• Evict low-priority content first; avoid synchronous deletions on main thread.

Battery & network efficiency

• Batch background work, respect Doze/Low Power modes, prefer Wi‑Fi or unmetered constraints.
• Backoff retry with exponential jitter; use TCP keepalive and reuse connections (HTTP/2).
• Use platform power APIs: Android JobScheduler/WorkManager constraints, iOS background tasks scheduling windows.

Observability & safety

• Instrument metrics: task queue depth, cache hit rate, memory pressure, idle/busy threads.
• Use strict ownership patterns, weak refs for UI callbacks, and automated leak detection (Memory Profiler, Instruments).

This design keeps UI work on main only, limits threads to optimal counts, uses platform schedulers, cancels work with lifecycle hooks, segments buffers to control memory, and relies on disk-backed caches with LRU eviction for battery- and memory-efficient streaming.

Direct answer

In the moment, my first job is to actually listen to the criticism rather than start explaining or defending myself before I've fully heard it, even when the instinct to justify is strong. Afterward, rebuilding trust isn't about the conversation where I received the feedback, it's about visibly acting differently going forward in the specific way the feedback pointed at.

Structured elaboration

• Managing the reaction in the moment: the instinct right after an outage, already stressed, is to explain the context and mitigating factors as soon as criticism starts. I've learned to let the person finish first, genuinely hear the specific complaint, and only then respond, since jumping in early to explain often lands as defensiveness even when that isn't the intent.
• Separating the valid signal from the delivery: tough feedback right after an outage often arrives with real frustration attached. The useful move is extracting the actual substance, what specifically should have gone differently, rather than reacting to the tone it arrived in.
• Not over-apologizing either: there's a version of managing the reaction that overcorrects into excessive self-criticism, which doesn't address the substance any better than defensiveness does; the goal is a level, accurate acknowledgment, not performing contrition.
• Rebuilding trust afterward: the actual trust repair happens in what changes afterward, doing the specific thing the feedback pointed at differently next time, not in how gracefully the original conversation went.

Worked example

Right after an outage I'd contributed to, my manager gave me direct, pointed feedback in a one-on-one: that I'd been slow to escalate once it became clear I was stuck, and that the delay had made the outage longer than it needed to be. My first instinct was to explain the reasoning that had made sense to me in the moment, that I'd thought I was close to a fix. I held off on that and let them finish first, and once I actually listened past my own defensiveness, the specific point was fair: I had, in fact, kept trying alone for longer than made sense given how the situation was unfolding.

I acknowledged the specific point directly rather than the vaguer "I hear you, I'll do better," and said what I'd concretely do differently: escalate earlier next time I'm stuck past a set point, rather than continuing to push alone. The actual trust rebuilding happened over the incidents that followed, not in that conversation. In the very next incident where I got stuck, I escalated well before I would have previously, and I made a point of telling my manager afterward that I'd deliberately applied the earlier feedback, which is what actually closed the loop for them, seeing the specific behavior change rather than just hearing that I'd taken the feedback well.

Trade-offs and pitfalls

The common failure mode is treating receiving feedback well as the whole task, being gracious and non-defensive in that one conversation and considering it handled. Without a visible change in behavior afterward, gracious listening reads as agreeable in the moment and forgotten a week later, which damages trust more than a defensive reaction followed by real change would. The other trap is swinging to excessive self-criticism, which can feel like taking it seriously but doesn't actually engage with the specific, actionable substance of the feedback any better than dismissing it does.

Direct answer

A coroutine is a lightweight unit of work that can pause without holding a thread and resume later; a function marked suspend is one that may pause this way, and while it is paused its thread is free to run other work. A dispatcher decides which thread (or threads) a coroutine runs on. For an app that downloads and decodes images: run the network download on Dispatchers.IO (blocking work that mostly waits), the image decoding on Dispatchers.Default (CPU-bound work), and the UI update on Dispatchers.Main (the single UI thread). Switch between them with withContext(...) (launch and async start new coroutines inside a scope, the object that owns them and cancels them together, such as viewModelScope on Android, which is cancelled when the screen's ViewModel is cleared; withContext instead moves the current coroutine to another dispatcher for one block), which suspends the caller, runs the block on the new dispatcher, and returns the result. The rule behind all three choices: put work that waits on IO, work that computes on Default, and work that touches UI objects on Main.

The three dispatchers

Dispatchers.IO and Dispatchers.Default share threads. The kotlinx.coroutines documentation says that withContext(Dispatchers.IO) while already on Default typically does not cause a real thread switch, because the implementation tries to keep execution on the same thread. So the cost of switching between them is small, and the two are separated by their parallelism limits, not by separate thread pools.

Per-stage choice and justification

1. Network download: Dispatchers.IO. The download is a blocking call. While it waits, the thread does no computation, so you want many of them parked at once. IO allows up to 64 (or the core count if larger), far more than Default could ever give you.
2. Image decoding: Dispatchers.Default. Decoding keeps a core busy the whole time. More threads than cores adds only context switching, so the pool sized to the number of cores is the right fit. Running decoding on IO would let 64 decodes fight over a handful of cores.
3. Updating the UI: Dispatchers.Main. Views may only be touched from the UI thread, and the code there should be tiny (set the bitmap), otherwise the screen stutters.

suspend fun loadImage(url: String): Bitmap {
    val bytes = withContext(Dispatchers.IO) { download(url) }        // waits on the network
    return withContext(Dispatchers.Default) { decode(bytes) }        // computes
}

// in the UI layer, on Dispatchers.Main (for example viewModelScope.launch):
imageView.setImageBitmap(loadImage(url))                            // runs back on Main

In numbers: on a machine with 14 cores, Default runs at most 14 threads and IO at most 64 (the larger of 64 and the core count); on a 2-core phone, Default has 2 and IO still has 64. Android's guidance is that suspend functions should be main-safe, meaning safe to call from the main thread: the function that does blocking work is responsible for moving itself off the main thread with withContext, so callers never need to know. It also says not to hardcode dispatchers, but to inject them (as constructor parameters with defaults), so tests can substitute a test dispatcher.

Runnable check on the JVM

The program below (Kotlin 2.0.21, kotlinx-coroutines 1.9.0, run on JDK 21) cannot use the real Dispatchers.Main, which needs an Android or Swing artifact, so a single thread named main-standin plays the UI thread. It runs the three stages in order, then tests a claim from the table: how many blocking tasks each dispatcher can hold at the same time. It starts cores + 1 tasks that each wait until all have started; that can only succeed if the dispatcher can run cores + 1 threads at once. Step by step: runBlocking is the entry point that blocks main until the coroutines inside finish (a program needs one to start coroutines from plain code). allBlockedTogether creates a CountDownLatch set to n, a counter that threads wait on until it has been counted down n times. Each of n coroutines, launched on the dispatcher under test, counts the latch down once and then blocks on it (up to 2 seconds) like a thread stuck on a network read. The caller waits up to 1 second for the count to reach zero: it reaches zero only if all n coroutines are running at the same moment. Then cancelAndJoin() cancels each coroutine and waits for it to end. Two small helpers appear in the stage lines: Thread.currentThread().name.substringBefore('-', "?") keeps the text of the thread name before its first dash (DefaultDispatcher-worker-3 becomes DefaultDispatcher, and "?" is the fallback when there is no dash), and the Thread.sleep(50) stands in for a blocking network wait.

import kotlinx.coroutines.*
import java.util.concurrent.CountDownLatch
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit

fun decode(bytes: ByteArray): Long {                    // CPU-bound stand-in for image decoding
    var h = 0L
    repeat(2_000_000) { i -> h = h * 31 + bytes[i % bytes.size] }
    return h
}

fun main() = runBlocking {
    // Stand-in for Dispatchers.Main (only exists with an Android or Swing artifact): one named thread.
    val mainExecutor = Executors.newSingleThreadExecutor { Thread(it, "main-standin") }
    val mainThread = mainExecutor.asCoroutineDispatcher()

    val stages = mutableListOf<String>()
    val bytes = withContext(Dispatchers.IO) {            // blocking download
        stages += "download on ${Thread.currentThread().name.substringBefore('-', "?")}-pool"
        Thread.sleep(50)                                  // blocking call: parks a thread, not CPU
        ByteArray(1024) { it.toByte() }
    }
    val bitmap = withContext(Dispatchers.Default) {      // CPU-bound decode
        stages += "decode on ${Thread.currentThread().name.substringBefore('-', "?")}-pool"
        decode(bytes)
    }
    withContext(mainThread) {                             // UI update
        stages += "update on ${Thread.currentThread().name}"
    }
    println(stages)
    println("decoded value is deterministic: $bitmap")

    // How many blocked threads can each dispatcher hold at once?
    val n = Runtime.getRuntime().availableProcessors() + 1
    suspend fun allBlockedTogether(d: CoroutineDispatcher): Boolean {
        val latch = CountDownLatch(n)
        val jobs = List(n) { launch(d) { latch.countDown(); latch.await(2, TimeUnit.SECONDS) } }
        val ok = latch.await(1, TimeUnit.SECONDS)         // true only if all n were running at once
        jobs.forEach { it.cancelAndJoin() }
        return ok
    }
    println("cores+1 = $n blocking tasks at once on Dispatchers.Default: ${allBlockedTogether(Dispatchers.Default)}")
    println("cores+1 = $n blocking tasks at once on Dispatchers.IO:      ${allBlockedTogether(Dispatchers.IO)}")
    mainExecutor.shutdown()
}

[download on DefaultDispatcher-pool, decode on DefaultDispatcher-pool, update on main-standin]
decoded value is deterministic: -3386939593423404480
cores+1 = 15 blocking tasks at once on Dispatchers.Default: false
cores+1 = 15 blocking tasks at once on Dispatchers.IO:      true

The output was identical in repeated runs (the container had 14 CPUs, so cores + 1 is 15; on another machine the number differs). Default prints false on any machine with two or more cores, because its limit is the core count and cores + 1 is one more than that. On a one-core machine its limit is the minimum of two, which equals cores + 1, so that line prints true there. IO prints true as long as cores + 1 is at most 64. The stage line shows download and decode both on DefaultDispatcher worker threads (the shared pool: IO and Default threads carry the same name prefix) and the UI step on the dedicated thread. The last two lines are the real difference: Default could not run 15 blocked tasks at once because its limit is the core count, while IO could.

Trade-offs and pitfalls

• Blocking inside Default. A blocking call on Default holds one of only a few threads; enough of them stall all CPU work in the app. The experiment above is that starvation in miniature.
• withContext(Dispatchers.Main) from an already-main coroutine does no useful work; do not scatter it. Put the switch at the boundary of the function that needs it.
• Many concurrent blocking operations for one resource: Dispatchers.IO.limitedParallelism(n) gives a view with its own limit for that resource (for example 4 connections to one database), and the documentation says such views are not restricted by the 64 limit of IO itself.
• Cancellation. withContext creates a child scope: if the calling coroutine is cancelled (for example the screen closes) before the block starts, the block finishes immediately with a CancellationException (the exception Kotlin uses to unwind a cancelled coroutine; it is treated as normal, not as a failure). A blocking call that never checks for cancellation, such as one Thread.sleep or a blocking read, keeps running until it returns, so prefer cancellable APIs.
• Do not decode on Main "because it is only a thumbnail". Many small stalls add up to dropped frames.
• Many images at once. Launch one coroutine per image; the dispatchers bound the real parallelism, so 200 queued downloads do not create 200 threads.

Approach (brief)
Use a pagination controller on the client that is agnostic to cursor vs offset. It keeps state: nextCursor/nextOffset, isLoading, isEndReached, error, and a deduplicated list. On scroll near-bottom it requests next page, merges results avoiding duplicates, updates end detection from server hints (has_more, next_cursor) or when fewer items than pageSize returned.

Cursor vs Offset (comparison)

• Cursor-based: stable, efficient at large data, avoids duplicate/skipped items when backend mutates. Use when data changes frequently.
• Offset-based: simple, random-access pages, but risk of duplicates/missing items and expensive for deep offsets.
• Recommendation: prefer cursor for infinite scroll; use offset for simple, static datasets.

Pseudocode / Interface (Kotlin-style)

interface Paginator<T> {
  var isLoading: Boolean
  var isEndReached: Boolean
  var error: Throwable?
  val items: MutableList<T>
  fun loadNext()     // triggers fetch
  fun reset()        // clear state and reload
}

class CursorPaginator<T>(
  val pageSize: Int,
  val fetch: suspend (cursor: String?, size: Int) -> Page<T> // backend returns items, nextCursor?, hasMore?
): Paginator<T> {
  var nextCursor: String? = null
  override var isLoading = false; override var isEndReached = false; override var error = null
  override val items = mutableListOf<T>()
  override suspend fun loadNext() {
    if (isLoading || isEndReached) return
    isLoading = true
    try {
      val page = fetch(nextCursor, pageSize)
      // merge without duplicates using id set
      val existingIds = items.map { it.id }.toHashSet()
      val new = page.items.filter { !existingIds.contains(it.id) }
      items.addAll(new)
      nextCursor = page.nextCursor
      isEndReached = !(page.hasMore ?: (page.items.size == pageSize))
      error = null
    } catch (e: Throwable) { error = e }
    isLoading = false
  }
  override fun reset() { items.clear(); nextCursor = null; isEndReached = false }
}

Key concepts & edge cases

• Deduplication: track IDs or hash of items to avoid duplicates after merges.
• End detection: prefer explicit server flags; fallback when returned count < pageSize.
• Error/loading UI: expose isLoading/error to UI; debounce scroll triggers; cancel inflight requests on reset.

Complexity

• Network: O(pages) calls. Client merge: O(n) per page to dedupe (using HashSet).
• Memory: O(total items held).

Alternatives

• Use diffing (RecyclerView/UICollectionView) for smooth UI updates.
• Combine cursor with server-provided stable sort keys for robust ordering.

Direct answer

Both parts use a two-pointer, write-in-place pattern. For deduplication, a slow pointer marks where the next unique value should be written while a fast pointer scans ahead; since the array is already sorted, duplicates are always adjacent, so comparing the current value only to the last-written value is enough. For the in-place merge, walk both arrays from their ends backward, writing the larger of the two remaining candidates into the last free slot each time, so the write never overwrites a value that still needs to be read.

Structured elaboration

Deduplication. slow tracks the index of the last unique value written; fast scans every element. Whenever nums[fast] differs from nums[slow], advance slow and copy nums[fast] there, so the prefix nums[:slow+1] always holds the unique values seen so far.

In-place merge. Given nums1 with real data in its first m slots and n more slots of trailing free space, and nums2 with n elements, use three pointers: i at the last real element of nums1 (index m-1), j at the last element of nums2 (index n-1), and k at the last slot overall (index m+n-1). At each step, whichever of nums1[i] or nums2[j] is larger gets written to position k, and that source pointer along with k both move one step back. The loop only needs to run until j is exhausted: once every element of nums2 has been placed, whatever remains at the front of nums1 is already smaller than everything placed so far and already sits in correct sorted position.

Writing from the back is what makes this safe without an auxiliary buffer: writing from the front would overwrite nums1 entries before they have been read and compared, which is exactly what the trailing free space is meant to avoid needing.

Worked example

def remove_duplicates(nums: list[int]) -> int:
    if not nums:
        return 0
    slow = 0
    for fast in range(1, len(nums)):
        if nums[fast] != nums[slow]:
            slow += 1
            nums[slow] = nums[fast]
    return slow + 1


def merge_sorted_inplace(nums1: list[int], m: int, nums2: list[int], n: int) -> None:
    i, j, k = m - 1, n - 1, m + n - 1
    while j >= 0:
        if i >= 0 and nums1[i] > nums2[j]:
            nums1[k] = nums1[i]
            i -= 1
        else:
            nums1[k] = nums2[j]
            j -= 1
        k -= 1


if __name__ == "__main__":
    arr = [1, 1, 2, 2, 2, 3]
    n = remove_duplicates(arr)
    print(n, arr[:n])

    nums1 = [1, 2, 3, 0, 0, 0]
    nums2 = [2, 5, 6]
    merge_sorted_inplace(nums1, 3, nums2, 3)
    print(nums1)

Running this prints 3 [1, 2, 3] and then [1, 2, 2, 3, 5, 6].

Complexity

remove_duplicates: time $O(n)$, one pass over the array with $O(1)$ work per element; space $O(1)$ extra, since the array is modified in place with only the slow index as bookkeeping.
merge_sorted_inplace: time $O(m + n)$, since each of the m + n elements is written into its final position exactly once; space $O(1)$ extra, since it writes directly into nums1's existing trailing free space using only three index pointers as bookkeeping.

Edge cases

• Empty input to remove_duplicates (nums == []): the function returns 0 immediately via its explicit if not nums check, without touching slow or fast.
• merge_sorted_inplace with n == 0 (nothing in nums2): the loop condition while j >= 0 is false immediately, so nums1's first m elements are left untouched, which is already correct.
• merge_sorted_inplace with m == 0 (nums1 starts with no real data): every element written comes from nums2, and the loop still terminates correctly once j is exhausted.

Trade-offs & pitfalls

A naive merge written from the front would need a temporary buffer, since it would overwrite nums1 entries before they are compared, defeating the point of the trailing free space. In deduplication, a common bug is comparing the current value to the last value the fast pointer saw rather than the last value actually written by the slow pointer; that breaks as soon as a run of duplicates is longer than two.