1. LandOffer
  2. Blog
  3. All articles
  4. Review Third-Party SDK Data Collection Before Adding It to an App

Engineering Practice

Review Third-Party SDK Data Collection Before Adding It to an App

A fictional Android save-result analytics proposal receives a completed data-and-permission review and a revised disabled-collection package. Twelve executed local XML and synthetic-event checks verify supplied artifacts, while resolved SDK version, merged permissions, runtime behavior, recipients, and disclosures remain explicitly unverified and block introduction.

9 min readLandOffer team

Before adding a third-party SDK, identify the exact component and resolved version, map its possible data collection to your intended use, and inspect the permissions and configuration of the app that will contain it. Keep vendor statements separate from your own build and runtime observations. If a version, destination, or collection condition remains unknown, give it an owner and a blocking decision instead of marking the SDK “privacy reviewed.”

This LandOffer.ai guide works through a fictional Android analytics proposal, a completed review record, and a revised configuration package. The primary documentation is real and was checked on October 27, 2026. The local XML and example-event checks were executed; no Firebase SDK, Android application, network capture, console, or user account was tested or changed.

An engineer reviews three desk panels labeled Vendor Claims, App Build Version Pending, and Runtime Not Observed beside a Hold Integration card.

Define what the SDK is supposed to accomplish

Write the product question before choosing a vendor category. “We need analytics” is too broad to justify access to every available signal. A question such as “Does the new save flow return a successful result?” can be examined against specific events, existing server evidence, and alternatives that collect less information.

Record what the team would lose by not adding the SDK. Distinguish a necessary app feature from an optional measurement convenience. Also identify who can decide that the trade-off is acceptable. An engineer can describe behavior and propose controls without silently becoming the owner of every privacy, contractual, and product decision.

Google Play’s SDK Requirements place responsibility on the app developer for included third-party code and its data practices. The guidance calls for understanding SDK permissions, collected data, and collection purposes. A supplier’s badge or integration guide does not replace that app-specific work.

Permissions are only one part of the review. A permission request may reveal access that needs explanation, but a short permission list cannot establish that no data leaves the device. Conversely, a capability present in a dependency does not prove that your configured app exercised it during a particular session. Record capability, declared behavior, and observed behavior separately.

Complete the review record without filling unknowns with guesses

QuietLedger is a fictional equipment-inspection app. Its draft records can contain equipment labels, customer-site names, and free-text maintenance notes. The product owner, Ren, wants to count successful and failed save attempts without using inspection contents. The proposed addition is Google Analytics for Firebase on Android, identified by the coordinate com.google.firebase:firebase-analytics.

This is a pre-integration review. No dependency has been resolved or installed for the example, so the exact version is explicitly unselected. Calling it “the latest SDK” would conceal that missing evidence. The review may proceed far enough to reject an unnecessary proposal, but it cannot approve a build that does not yet exist.

The Analytics Android disclosure guidance says its information describes the latest SDK and distinguishes automatic collection from behavior dependent on configuration and use. Its listed defaults include app-instance and advertising identifiers, coarse location derived from masked IP addresses, and app lifecycle events. Treat that as vendor documentation about the product, not a captured inventory from QuietLedger.

Here is the completed intake record. “Pending” is a recorded result, with a next step, rather than a blank field disguised as clearance.

Review item Evidence available now QuietLedger decision and next owner
Intended benefit Ren’s fictional request is save-result visibility, without advertising or audience targeting Compare existing error reporting first; Ren owns the need decision
Component and version Android Analytics coordinate identified; exact resolved version and indirect dependency graph absent No integration approval; developer Inez must retain resolved artifacts if the proposal continues
Automatic collection Current vendor disclosure lists identifiers, coarse location derivation, and lifecycle events Do not infer that a two-field custom event limits all SDK collection; privacy reviewer Sol must assess the full inventory
App-defined fields Draft proposal includes record title, note text, account email, and asset serial Remove all four from the measurement proposal; they are unnecessary for Ren’s stated question
Permissions and APIs No merged Android manifest or packaged app exists Inez must inspect the actual release variant; no claim that permissions are absent
Destinations and integrations No console or app traffic has been inspected Sol and the service owner must identify recipients, linked services, processing terms, and retention settings
Lifecycle controls Android documentation supplies collection-deactivation and advertising-ID controls Prepare a disabled-build example; real initialization and lifecycle behavior remain unverified
Release disposition Required version, build, runtime, and data-handling evidence is missing Hold the SDK addition; keep the existing save workflow unchanged

The review exposes a trade-off: a narrow save-result question would introduce a broader data relationship. The team has not established that the extra collection is necessary. Removing the proposed email field leaves the automatic-identifier and recipient questions unresolved.

Do not merge different identifiers into one row merely because they sound anonymous. The vendor guidance distinguishes an app-instance ID from a User-ID that the developer sets. Whether a data element can be linked, how it is used, and which disclosures apply require their own review. Hashing an email is not a shortcut to an assumption that the resulting value carries no privacy implications.

Revise the proposal and keep collection disabled

Ren narrows the fictional request to whether a save attempt succeeded. The revised candidate event contains only event_name: save_result and result: success or failure. It excludes record titles, note contents, email addresses, and asset serials. This is an authored event proposal, not a Firebase export or a statement that the SDK accepts only these fields.

A local dictionary check confirms that the supplied synthetic draft can be reduced to those two named fields and that the four excluded fields are absent from the reduced object. It does not send an event. It also does not remove automatic SDK data, validate every possible future event, or establish that developers cannot bypass a proposed wrapper.

For a future review branch that includes Analytics but should keep collection deactivated in that app version, the official Android configuration guide documents the following settings inside the application element:

<application>
    <meta-data
        android:name="firebase_analytics_collection_deactivated"
        android:value="true" />
    <meta-data
        android:name="google_analytics_adid_collection_enabled"
        android:value="false" />
</application>

The first setting is the documented permanent-deactivation option for that app version, not the separate temporary collection-enabled setting. The second explicitly disables advertising-ID collection. Disabling that identifier alone would not disable all Analytics collection. Keep the two purposes distinct when reviewing a configuration diff.

The supplied local manifest example was parsed with Python’s XML library. Twelve checks verify the two metadata elements’ placement, distinct names and literal values, the absence of permission declarations in this snippet, and the reduced example-event fields. The twelve passing checks establish only the contents of these supplied local artifacts. They do not exercise the Android manifest merger, run an emulator, initialize Analytics, or measure traffic.

The second completed asset is the revised package and disposition record:

Proposed change Completed local evidence What remains unproven
Remove four unnecessary custom fields Synthetic before-and-after event objects and exclusion assertions retained Actual callers, future fields, and real event payloads
Use the Android deactivation setting XML contains the documented key with true under application Packaged variant, SDK-version compatibility, initialization, and runtime behavior
Disable advertising-ID collection explicitly XML contains the documented key with false Absence of every other identifier or collection path
Avoid adding permissions in this example The standalone snippet declares none Permissions merged from actual dependencies or app manifests
Keep integration held Fictional review record names unresolved items and owners No build, store declaration, account setting, or rollout approval exists

The immediate decision is to defer adding the SDK, not to ship the disabled example as a supposedly verified app. Inez keeps the snippets as review materials only. Ren will first examine whether existing save-error evidence can answer the question. Sol’s recipient and disclosure review remains open if the SDK proposal returns.

Plan observations that can challenge the documentation

If the team later authorizes a test build, record the exact dependency graph, build variant, platform versions, configuration, and app actions for each observation. Check a fresh installation before optional choices, an allowed-collection path if the design has one, and a later change of preference. Treat permanent deactivation and temporary preference flows as different configurations rather than mixing their expected behavior.

Include backgrounding, relaunch, offline activity, and reconnection where relevant to the chosen SDK. Buffered events can make a single short session misleading. Label a scenario not run as pending; do not invent a clean capture because the setting looks correct in source.

Compare the built artifact with the source proposal. Manifest merging, build flavors, indirect components, or another initialization path can change what the app contains or does. Search application code for explicit user identifiers and free-text event parameters, and review linked services separately. A custom-event allowlist is useful only within the call paths that actually enforce it.

When network inspection is authorized and technically available, retain bounded observations: which scenario ran, what destinations were visible, what payload information could be inspected, and what encryption or tooling prevented you from seeing. “No request observed in this interval” is different from “this SDK never transmits data.” Use synthetic records and avoid collecting someone else’s private session as convenient evidence.

Set a re-review trigger alongside the acceptance conditions. An SDK upgrade, a new advertising integration, an added event parameter, or a changed initialization path can invalidate part of the earlier record. Preserve the previous version and configuration so the next reviewer can compare changes instead of starting from an undated supplier summary.

A failed observation should name the mismatch without assigning a cause prematurely. If an unexpected identifier appears, retain the synthetic scenario and trace, check the emitting component and configuration, and hold the affected path. Do not attribute every request to the newly proposed SDK solely because it was added recently.

The reviewer should also ask what happens after collection. Destination ownership, retention, deletion mechanisms, onward integrations, and contract terms are not answered by seeing a single request. Disabling future collection does not, by itself, demonstrate deletion of previously transmitted records. Resolve those questions through the relevant service and privacy owners.

An illustrated worksheet retains Event and Result, crosses out Title, Note, Email and Serial, and places Deactivated configuration beside a version, permissions and runtime pending list.

Record an introduction decision that can be revisited

The fictional closing note reads: “Defer Firebase Analytics integration. The stated save-result question does not yet justify the documented collection surface. Four unnecessary custom fields have been removed from the proposal, and a documented deactivated configuration has passed local syntax and content checks only. Exact dependency resolution, merged permissions, runtime behavior, recipient review, and disclosures remain pending. Reopen when Ren establishes the need and Inez supplies an authorized test-build record.”

That note does not declare the vendor unsafe, the app compliant, or the setting ineffective. It explains what evidence exists and why it is insufficient for this introduction decision. The named evidence gaps give the team a concrete condition for reopening the review.

Before a later release, reconcile the resulting data inventory with the actual platform’s disclosure requirements and your app’s notices. Have the responsible owners resolve policy and contractual questions in context. An Android review cannot be copied into an Apple submission or a different SDK version without checking the relevant definitions and behavior again.

For your next SDK proposal, complete one data-and-permission record and one configuration diff before treating installation as progress. Keep unknowns, observations, and vendor claims visible beside the decision. More practical engineering guides are available from LandOffer.ai.

Sources and Further Reading