Teardown worksheet

3. The universal app model

UIScreen stateDomain logic on the clientShared data layerLocal storeNetwork clientSync engineBackground workersPlatform servicesPlatform services usedGatewayServicesBackend storeChange logAsync deliveryMedia deliveryThird partiesThird parties seenClosest subsetEvidence and open questions

4. Probes

Stored data on the deviceLaunch in airplane modeAfter a force-quitAfter a long time in the backgroundChange made on a second deviceFresh installMobile data and battery figures, with the period they coverTest conditions: devices, network, app versionChapters to read next

6. The teardown worksheet

App nameStore categoryApp version testedDate of the teardownPlatforms and devices testedAccounts used, and any plan or region that may change behaviorDepthArchetype guessFeatures in scopeFeatures left outClient components presentBackend components presentDominant concerns and the chapters usedPublished statements from the maker, with source and dateBackend sketchOpen questions, each with the probe or publication that would settle itSummary of findings with confidence words

7. Launch and startup

First-screen strategyCold start against returnCold start with no networkSession check at startupRemote config at startupLanding ruleLaunch from a notificationLaunch after a device restartFirst launch after installLaunch after a long absenceFirst launch after an updateUpdate gateEvidence of deferred or lazy initializationBackend components impliedFailure modes seen

8. Navigation, deep links and screen state

Navigation structure: tabs, stacks, modals and flowsTab historiesUnfinished inputRestored after process deathSurvives a force-quitLink formLink while signed inBack stack after a linkLink into a running appLink while signed outLink with the app not installedEvidence of navigation decided by the backendFlow state locationBack behavior worth notingBackend components impliedFailure modes seen

9. State and UI data flow

Where the feature's data livesList after a change on the detail screenOther surfaces after a changeSurfaces found staleWhat makes the screen updateOptimistic updateBadges and countsFailed refresh over contentLoading, empty, error and partial states seenRotation or resizeAfter process deathChange made from outside the appChange from a second device reaches an open screenBackend components impliedFailure modes seen

10. API shape

API shape for this screenWho composes the screenFirst paint on a normal connectionLoad on a weak connectionFailure unitList against detailChange without an app updateOld version behaviorWhat an action returnsWhere computed values are decidedRejected inputWhere display text is builtBackend components impliedClaims left SpeculativeFailure modes seen

11. Local storage, caching and prefetching

Kinds of storage in evidenceCache tiersRead policyEstimated time limitExpired data offlineCache shapeInvalidation in evidenceDisk cache boundClear-cache controlDetail screen data sourcePrefetch forms seenPrefetch on metered networkFetch ahead of openingLocal data at sign outBackend support impliedFailure modes seen

12. Offline and sync

Offline levelOffline read scopeOffline write actionsPending mutations survive force-quitOutbox drain triggerRejection behaviorIdempotency evidencePull triggerDelta or full refetchFirst sync orderConflict unitConflict detectionConflict resolutionDelete against edit ruleBackend components impliedFailure modes seen

13. Network transport and resilience

Network handling stepFailure detected after a cutTimeouts on a weak networkRecovery when the network returnsRetry and backoff evidenceFailed writesRequest for a screen the user leftForeground against heavy transfersAdaptation to a weak networkWireless to cellular mid-actionDevice data-saver modeCaptive networkHow network state is shownOutage and failover observationsBackend support impliedNetwork conditions of each run and failure modes seen

14. Real-time delivery

Foreground delay measuredForeground mechanismPolling interval if seenSubscription scopeBackground deliveryRole of platform pushDelivery after force-quitWith notification permission offCatch-up on reconnectAcknowledgments shown to the senderFan-out to the user's devicesEphemeral signals presentEphemeral signal expiryBackend components impliedFailure modes seen

15. Lists, feeds and pagination

List orderPaging presentationPage size countedNext page requestedPaging methodRanking stability on refreshHow new items arrivePosition after a short absencePosition after a long absenceGap handlingEntry at an anchorPlaceholders and scroll indicatorList available offlineList and detail consistencyBackend components impliedFailure modes seen

16. Images

Image sizing designStand-in before arrivalHow an image fills inSpace before arrivalFull-screen and zoomImage cache tiersDetail image sourceFast scroll behaviorImages under data-saver modeImage disk cache boundPreparation before uploadFormat and quality evidenceBackend support impliedFailure modes seen

17. Audio and video playback

Delivery designReaction to a slower networkStart delay and what shortens itSeekingBuffer aheadNext itemScreen lockedApp left during videoCalls and headset removalPosition after force-quitPosition across devicesOffline downloadsExpiry and protected content evidenceCaptions and audio tracksAutoplay in feedsBackend support implied

18. File transfer: uploads and downloads

Transfer feature examined and file size usedShape of the transferAfter an interruptionRecovery when the network returnsNetwork switch mid-transferUpload while the app is off screenUpload after a force-quitOwner of the transferWork before uploadOrder of file and itemSeveral files at onceLarge transfer on cellularDownload after pause and force-quitStorage after a cancelled downloadBackend support impliedProgress reporting, network of each run and failure modes seen

19. Live calls and live streaming

Live media the app offersCall delay measured side by sideEcho on speakerOn a weak networkNetwork switch mid-callIncoming call with the app force-quitWhen a third person joinsMedia pathGroup call serverStated participant limits and what changes at sizeLive stream delay against a clockLive stream deliveryChat against pictureAfter falling behind the live edgeBackend components impliedMeasured delays, network of each run and failure modes seen

20. Identity and sessions

Sign-in methods offered, by momentSecond factor at sign-inSession with no networkReturn after idleBiometric unlockConcurrent devicesDevice listRevocation reaches the devicePassword change elsewhereAfter a long absenceAfter a reinstallGuest state at conversionAccount recoverySeveral accountsBackend components impliedFailure modes seen

21. Security and trust

Posture for this featureActions with value while offlineValidationScreenshot of a sensitive screenApp switcher cardScreens with capture protectionSecond proof before a sensitive actionActions that ask for a second proofOne-time code limitResidue after sign outBehavior on an intercepting networkDevice integrity requirementBackend components impliedFailure modes seen

22. Privacy, permissions and consent

Permissions requested and the feature each servesRequest timingExplanation screen before the system promptWhen deniedAsking again after a refusalAfter revocation in settingsApproximate locationPhoto accessAfter declining tracking and non-essential useWhere consent is storedRegional differences seenAccount deletion pathData exportStore listing against behaviorFeatures processed on the deviceFailure modes seen

23. Background work and notifications

Notification categoriesLong-running work in the backgroundWho writes the notificationNotification after a force-quitA write in progress when leavingNotification actionsAfter reading on another deviceBadge count sourceNotifications in low-power modeScheduled notificationsNotifications after an offline periodRefresh while unopened for daysGrouping, images and in-place updates seenBackend components impliedFailure modes seen

24. Location, sensors and hardware

Hardware and permissions the app usesLocation mode on screenLocation in the backgroundWith approximate location onlyWith location deniedRoute recorded in the backgroundReadings taken offlineBattery share after a sessionSource of step and motion dataCapture pathScanning offlineWith hardware unavailableAccessories and tap interactionsBiometric check and what it protectsBackend components impliedFailure modes seen

25. Platform surfaces: widgets, wearables and extensions

Surfaces the app hasWidget after a change in the appWidget after a change elsewhereDoes the widget show the age of its dataLive status updatesAssistant and shortcut actionsShare targetWatch app with the phone offWatch writes with the phone offSurfaces after sign-outHow each surface gets data and sessionInstant version, car and television surfacesBackend components impliedFailure modes seen

26. Payments and subscriptions

What is soldPayment routePayment surfacePayment record createdPending state and how it resolvesPaywall prices offlineRestore purchases keyed toEntitlement on a second deviceEntitlement offlineWhere a subscription is managedSubscription lifecycle states seenSaved payment methodsRefund path and who grants itBackend components impliedFailure modes seen

27. Ads, attribution and growth

Ads presentAd formats and where each appearsAd slot offlineRewarded ad readinessFull-screen ad frequencyEvidence of several ad sourcesEffect of declining trackingReferral across installationInvitation mechanismRating prompt triggerRe-engagement notificationsPromotional contentBackend components and third parties impliedFailure modes seen

28. Search and discovery

Search surface examinedWhere the search runsOffline search scopeWhat triggers a queryStale results under fast typingMisspelling toleranceWhere a new item is late to be foundMeasured time until a new item is searchableFilters and countsRanking across accountsRecent searchesVoice inputSuggestion and completion rows seenBrowse and recommendation surfaces and whether they differ by accountBackend components impliedFailure modes seen

29. Personalization and on-device intelligence

Smart feature examinedWhere the model runsResponse time on strong and weak connections and offlineHow the model reaches the deviceStorage growth after enabling the featureWhat a new account seesFeedback delayWhere the profile is keptWhat the app appears to learn fromAssistant response deliveryEffect of the personalization controlBackend components impliedClaims that remain Speculative and what would settle themFailure modes seen

30. Remote config and experiments

When config is appliedChange without an updateAnnounced feature on a current versionTwo accounts comparedTwo devices of one accountUnit of assignmentFirst against second launch after installFirst launch with no networkVariant after a reinstallTargeting by regionFeatures seen under a flag or an experimentBackend components impliedClaims left SpeculativeFailure modes seen

31. Server-driven UI

How much of this screen the backend decidesStructure change without an updateArrangement across refreshesShared quirks across screensThe screen with no networkWhere taps leadInteraction inside the screenEmbedded web tellsOld version on the same screenTwo platforms comparedScreens that the backend describesBackend components impliedClaims left SpeculativeFailure modes seen

32. UI technology: native, cross-platform and web

Dominant UI familyConfidence in the family claimFamily per screenText selectionSystem text sizeScreen reader structureSame screen on two platformsScreen in airplane modeRefresh behaviorScrolling feelSeam between app and web contentApp size and startupShared-code claim and its confidenceSeams and failure modes seen

33. Releases and compatibility

Release cadenceRelease notesUpdates outside the storeWhen an update is offered to two devicesUpdate promptUpdate flowFirst launch after an updateWhat an old version can doA new feature on an old versionCompatibility policyOldest version seen workingBackend components impliedClaims left SpeculativeFailure modes seen

34. Observability

Diagnostics or usage settingPrivacy listing declaresConsent for analyticsFeedback attachmentsReport prompt on screenshot or shakeData used on an idle dayUpload after a read-only offline sessionLaunch after a natural crashChannels claimed, each with a confidence wordThird parties the maker namesSession recording evidenceFailure modes seenOpen questions

35. Performance and resource budgets

Download size on the store listingInstalled size, app partOn-demand resourcesStorage trendBackground battery useData used in a day and what was consumedData patternHeavy list scrollReturn after ten minutes awayLow-power modeSustained usePostureTrades observed, such as data spent to save timeFailure modes seen

36. Constrained devices and networks

Small variantDownload sizes, variant and full appVariant designIn-app data controlsDevice data-saver modeWeak connectionStorage controlsLow-storage behavior, only if seen naturallyFallback outside the appTwo classes of deviceMinimum operating system version on the listingOld operating systemApproaches in useDevices and networks tested onFailure modes seen

37. Accessibility and global reach

Main task with the screen readerText scalingDark appearanceReduced motionTouch targets that are too small or too closeText after a language switchText that comes from the backendRight-to-left layoutEffect of the device region settingTimestamps after a time zone changeTimes at a place and day boundariesLarger or resized windowLegal terms by regionFeatures that differ by regionRegional data storage claim and its confidenceFailure modes seen

38. Modularity, SDKs and team scale

Licenses screenLibrary and SDK categories the maker listsStore privacy listingVisual consistency across areasBehavioral consistency across areasBorders where several things change at onceDownload at first useRelease rhythmApp size for its scopePrompts at first launchParity across platformsScreens supplied by third partiesModule structure claim and its confidenceQuestions that cannot be observed

39. Messaging

Main copy of historyWho can read message contentIdentityMulti-device modelConversation orderStatus stages shownDelivery to a recipient who is offHistory on a new deviceOld history on a second deviceInterrupted media uploadSearchDelete for everyoneGroup behavior: size limit, status detail, history for new membersNotes and open questions

40. Social feed and stories

Home feed orderWhere feed items come fromFirst screen after a gapLike while offlineHow a counter catches upEffect of follow and unfollow on the feedWhere the feed is assembledPublishing through an interruptionStory media before the first tapStory seen-state across devicesStory expiryAds in the feed and in stories: position, label, behavior offlineComments and notifications: how they arrive and where a tap landsNotes and open questions

41. Video and short-video streaming

Form of the productWhere the video comes fromClips ready ahead in the swipe feedPreloading on a metered networkData cost of skipping against watchingStarting quality levelTime limits on downloadsPosition reached offlineAfter a creator uploadSwipe feed after a restartLive streams: measured delay and behavior after falling behindMeasured start delays, data figures and the network of each runNotes and open questions

42. Audio streaming and podcasts

VariantTrack boundaryPlay queue across devicesHanding playback to another deviceOffline queue at an item not on the deviceDownloads after sign-outStated license rules: expiry, online check and device limitNew episode while unopenedWho reads episode feedsRule for two positionsSurfaces: lock screen, watch, car, widget, voice actionsBehavior on a call and on headset removalNotes and open questions

43. Marketplace and e-commerce

Seller modelHome and campaign screensWhere the cart livesGuest cart at sign-inCart changes offlineCart totalsWhere stock is checkedPrice and stock in an old cartCheckout after a force-quitHow an order status change arrivesPromotions seen: banners, codes, timed sales, and how each arrivedReviews and images: when a new review becomes public, image loadingNotes and open questions

44. On-demand services: rides and delivery

Parties to one jobTrip or order states seenPrice before confirmingNearby markers before a requestMatching while the app is awayActive trip after a force-quitMarker after a network gap on the customer's deviceThe same trip on a second deviceArrival-time estimate and how it behavesContact between the partiesWhen the money movesFinal price against the first priceEvidence about the provider's app, seen from the customer's sideNotes and open questions

45. Booking and reservations

What is bookedInventory formHold before paymentWhen inventory is takenCountdown after a force-quitHold after leaving the flowAvailability on another deviceBooking flow offlinePrice between search and summaryWaiting roomTicket offlineTicket codeBooking on a second deviceChanges, cancellations and open questions

46. Banking, payments and fintech

VariantBalance without a networkUnlock on return to the appIdle timeout inside the appTransfer started offlineWhere the step-up proof sitsPending and settled entriesDevice bindingWhat a new device must doLive pricesAlerts that cannot be turned offScreens and delays that come from regulationNotes and open questions

47. Maps and navigation

VariantHow the map is drawnTiles available offline without a downloadDownloaded region contentsRerouting with no networkNavigation with the screen lockedTraffic layer with no networkPlace search with no networkStorage managementSizes: app, one downloaded region, cache after a weekSpoken prompts offlineSurfaces: lock screen, watch, car display, widgetBattery share after an hour of navigationNotes and open questions

48. Notes, documents and collaboration

VariantWhen an edit is committed to the local storeText after a force-quit while typingConflict unit of the bodyResult of edits made apartArrival of another editor's textLive cursors and presenceVersion historyAttachment added offlineSearchRemoved access on an offline replicaFirst sync on a new deviceNotes and open questions

49. Meetings and calling

VariantHow a call startsRinging across devicesLink without an accountLink with the app not installedJoining before the hostHost mutes a participantWhen the host's app is goneIn-call chatAfter an outageAudio route changesRecording: where it is made, where it appears and after how longStated participant limits and what changes at sizeNotes and open questions

50. AI assistants

VariantStop mid-answerApp backgrounded mid-answerNetwork drop mid-answerAirplane-mode testConversation history across devicesRegenerateAttachment orderUsage limitsVoice mode: delay, interruption, behavior in the backgroundLong-running tasks and how they announce themselvesControls for the use of conversationsNotes and open questions

51. Health, fitness and connected devices

VariantRecording after a force-quitRecording without a networkUpload of a saved workoutSource of steps and daily activityAccessory sync triggerData from time away from the phoneWatch appSame workout from two sourcesUse of the platform health data storeAfter health access is revokedFirmware update when you leave the appConsent and privacy: what is asked, when, and what can be exported or deletedNotes and open questions

52. Games

VariantAsset deliveryPlay with no networkOffline progress after reconnectWhere the save livesTwo saves from two devicesHow an event arrivesOwn movement in a real-time matchReturn to a matchCurrencies, what each buys and which are soldRewarded ads and what each grantsMatchmaking: waiting time, what it seems to match on, computer opponentsNotes and open questions

53. Super-apps and mini-programs

VariantFirst open of a serviceIdentity across servicesPayment across servicesDevice permissions across servicesHome screen across accounts and regionsReturn to a serviceStorage after opening new servicesFrame around each serviceUI family per serviceHow services are found: home grid, catalog, search, links, scanned codesSeams seen between servicesNotes and open questions

54. Apps with no backend

VariantAccountA week without a networkNetwork use over a weekThird parties named or declared: ads, analytics, crash reports, store billingWrite interrupted by a force-quitPath to a second deviceExport and importConflict in platform syncHow the app earnsPurchase on a second deviceHardware used, the capture path and the degraded mode without each permissionFirst launch after an update with data in placeNotes and open questions

55. The app that fits no archetype

Shape of the appFeatures, one per line, with the data and the people each involvesDominant concerns per feature, with the chapters usedNearest archetype per feature, and where the feature departs from itOffline behavior across featuresSeams between featuresPhysical step without a networkHow features share a changeProbes you wrote, each with its outcomes listed before you ran itOpen questions, each with its candidates and what would settle it

Teardown worksheet

Fields

Probe results

Export