Skip to content
GrowmoonGrowmoon
WhatsApp LinkedIn

What to check before an API integration or app takeover

Before you connect a new API or take over an existing app, verify who controls the code, accounts and data. Use this checklist to test whether the app can be rebuilt, how integrations recover from failures and what your team receives at handover.

Illustration: a set of keys being handed between two hands above an app box with an open padlock and connector cables

Inventory the code, systems and accounts

List the code repository, build instructions, deployment environment, database and integrations. Record who controls each account and confirm the right to modify the code. Agree how to grant access securely. Keep credentials out of website forms.

Rebuild the app in a clean environment

A working live application is not the same as a reproducible build. Check whether a clean environment can install dependencies, build the application and run the important journeys. Record missing configuration, version assumptions and external services. Use a staging environment before changing production.

Map API contracts and data responsibilities

For each integration, document input and output formats, authentication, required permissions, rate limits and version expectations. Decide which system is the source of truth for each field. Identify personal or sensitive data and where it needs to be restricted or omitted. Avoid copying full production datasets merely to make testing easier.

Plan for repeated and failed requests

Webhooks can be delivered more than once and responses can be lost after a successful write. Define stable request identifiers and safe retry behavior. Confirm that a second delivery does not create another payment or order. When the result is uncertain, reconcile the existing request rather than blindly starting a new one.

Check account permissions and how secrets are shared

Check account ownership, repository access, environment configuration and the permissions granted to integrations. Remove access that is no longer needed through a planned change. Rotate credentials where the handover requires it, checking dependent systems first. Client-side validation alone does not enforce database or server permissions.

List the tests that determine acceptance

Test a valid request, invalid input, expired access, denied permissions, a vendor timeout, a duplicate event and a partial failure. Check the user-facing message and the saved result. A success screen should correspond to a confirmed outcome; a click or a request being sent is not enough.

Plan release and rollback

Agree the change window, backup checks, deployment steps and a practical rollback path. Know which database changes are reversible. After deployment, verify the critical journeys, logs and notification destinations. Record who can respond if a dependency fails outside normal working hours.

Separate repair from modernization

Prioritize defects and immediate operating risks, then consider structural improvements. A full rewrite is not automatically the best option. Compare the cost of stabilizing the existing application with a staged replacement, using evidence from the code and environment rather than its age alone.

Inspect the saved record behind an API retry

Agree what should exist after a repeated request, a lost response and a notification failure. Ask to inspect both the caller’s result and the saved record. A completion message should correspond to the outcome in the agreed acceptance contract.

For a real provider, use its current documentation. Stripe, for example, documents repeated webhook events and provider-specific deduplication decisions. Its API v1 and v2 idempotency behavior also differs. Confirm the actual interface and version before choosing a retry rule. Stripe webhook guidance, Stripe idempotent requests.

A local educational example you can inspect

Growmoon prepared a small original Python exercise using an invented booking event. The payload contains an event ID, booking ID, synthetic customer reference and seat count. A SQLite database stores the accepted event and a separate pending-notification entry. Notifications go to an in-memory fake.

The exercise was reproduced locally on 5 November 2026. Ten test methods passed. The table describes those synthetic checks; it does not report a delivered client integration or a real CRM result.

Ten local educational checks
Local checkExpected resultObserved in this exercise
Accept a valid fixture and reopen the databaseRetain the accepted event and pending notificationOne accepted row and one outbox row remain after reopen
Repeat the same event with equivalent fieldsReuse the acceptance without an extra rowReplay recognized; counts remain one and one
Reuse the event ID with changed fieldsReject the conflict without overwriting the originalChanged seat count rejected; original record unchanged
Inject two temporary failures before savingRetry within the declared three-attempt capAcceptance on attempt three; one accepted/outbox pair
Keep failing before savingStop at the retry cap with no partial acceptanceThree failed attempts; zero accepted/outbox rows
Supply missing or invalid fieldsReject the input without saving itMissing ID, invalid/boolean seat count and extra-field variants rejected
Lose the response after the local commitFind the original acceptance before creating againLookup reconciles one saved acceptance
Make the fake notifier fail onceKeep acceptance, then retry the notificationAcceptance survives reopen; second fake call marks the entry sent
Keep the fake notifier unavailableStop notification retries and retain visible failureThree fake attempts; saved event retained and notification marked failed
Fail between the accepted-row and outbox writesRoll back both writesInjected SQLite failure leaves neither row

A sent status here means the fake accepted a function call. The example exposes Python functions and local database state. HTTP, authentication, a real network timeout and real email or CRM delivery are outside this exercise. Invalid-input variants are subcases inside one of the ten methods.

Check where a small example stops

Two additional local observations show why the real contract still matters.

Different events for the same booking. Giving the same booking two different event IDs created two accepted rows. The example deduplicates an event ID. It does not decide whether two events represent one business action. Ask which identifier represents the operation you need to protect, including amendments and out-of-order updates.

Acceptance before a local status update. An injected interruption after the fake accepted a notification left the local entry pending. Retrying called the fake again. This model therefore does not guarantee exactly-once notification delivery. Ask how the actual destination identifies repeats and how an uncertain result is reconciled.

Bring an acceptance worksheet to the proposal review

Use one row for each business action. Keep assumptions next to the evidence so the reviewer can identify what was implemented and what remains proposed.

Integration acceptance worksheet
DecisionRecord before implementationEvidence to inspect later
Intended outcomeSource, destination, fields and owner of the final recordVersioned input/output mapping and saved synthetic record
Allowed callerRoles, permissions and expired/denied-access behaviorPermitted and denied journeys in the actual authorized test environment
RepetitionOperation identity, retention and conflicting-input ruleEquivalent replay, conflicting replay and relevant business-duplicate cases
Uncertain resultStatus lookup or reconciliation owner before any new creationSaved record plus the caller’s uncertain/recovered state
NotificationSeparate accepted, pending, sent and failed meaningsDestination acknowledgement, retry cap and recovery evidence
OperationsSupport owner, incident visibility and handover requirementsAgreed runbook, access ownership and recorded limitations

An acceptance example should name its source version, fixtures, expected result, observed result and reviewer. Mark an unsupported case explicitly. Authentication, permissions and real provider behavior still need their own evidence when the system and access are known.

Discuss the integration you need to hand over

Bring one source-to-destination workflow, the record you expect to save and an exception you need to handle. Include the people who own the systems and the first-release boundary. Those details support a useful scope discussion.

Download the educational source and local check receipts (ZIP). This archive contains the local exercise and its recorded limitations. The local test receipt (JSON) lists the ten checks, the code hashes and the limits of the run.

Related pages: API development, Custom software scope, Working arrangements.

Ask for a versioned field map before accepting an integration

Write the mapping at field level

“Send bookings to the CRM” leaves several purchasing decisions open. Use a field map to identify where values come from, where they will be saved and what happens when the source changes.

This invented table is a discussion example. It is not the contract of the existing local exercise or any real provider.

Write the mapping at field level
Synthetic inputProposed destinationDecision required before implementation
event_idReceipt referenceDefine the provider's event identity, retention period and conflicting-payload rule.
booking_idBusiness booking referenceDecide when a later event updates one booking and when it represents a separate action.
customer_refPermitted customer referenceAgree the source of truth and permitted lookup; keep private customer data out of examples.
seat_countRequested quantityDefine the type, allowed range and correction path.
Source revision or timestampReconciliation contextDecide how an older event is identified and whether it may change a newer record.
Destination record IDCaller reconciliation referenceDefine how a caller finds an accepted operation after losing its response.

Save the map with the source and destination versions, author, approver and test fixture revision. If an HTTP interface uses OpenAPI, pin the description version and document its operations, request/response definitions and security requirements. OpenAPI is an interface description; implementation evidence still needs separate checks. OpenAPI Specification 3.2.1.

Inspect the evidence against the proposed contract

Choose one valid fixture and compare the input, caller-visible result and saved destination record. Repeat with changed data under the same event reference, a later event for the same booking and a denied caller. Each outcome needs its own expected state. The worksheet should distinguish a case that passed from a case still unimplemented.

The existing educational exercise verifies selected local Python and SQLite behavior. Its recorded boundaries include two distinct event IDs creating two rows for the same booking, and a repeated fake notification after an injected interruption. A real contract must resolve the relevant business identity and uncertain delivery behavior. The exercise does not establish HTTP authentication, actual provider behavior or real CRM delivery.

Add an operating owner to every unresolved case. Identify who can inspect the destination, who can authorize a retry and which reference links the records. Agree whether failed notifications leave the underlying business record accepted. Those choices affect both implementation and support scope.

Bring one system pair, a permitted interface sample and the expected saved result to an API scope discussion. Keep the existing guide's source archive and test limitations beside the map so the buyer can distinguish proposed rules from observed evidence.

Discuss your app or API integration

Share the workflow, product or integration you have in mind. We will use the brief to discuss scope and a sensible next step.

Start a project conversation