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.
| Local check | Expected result | Observed in this exercise |
|---|---|---|
| Accept a valid fixture and reopen the database | Retain the accepted event and pending notification | One accepted row and one outbox row remain after reopen |
| Repeat the same event with equivalent fields | Reuse the acceptance without an extra row | Replay recognized; counts remain one and one |
| Reuse the event ID with changed fields | Reject the conflict without overwriting the original | Changed seat count rejected; original record unchanged |
| Inject two temporary failures before saving | Retry within the declared three-attempt cap | Acceptance on attempt three; one accepted/outbox pair |
| Keep failing before saving | Stop at the retry cap with no partial acceptance | Three failed attempts; zero accepted/outbox rows |
| Supply missing or invalid fields | Reject the input without saving it | Missing ID, invalid/boolean seat count and extra-field variants rejected |
| Lose the response after the local commit | Find the original acceptance before creating again | Lookup reconciles one saved acceptance |
| Make the fake notifier fail once | Keep acceptance, then retry the notification | Acceptance survives reopen; second fake call marks the entry sent |
| Keep the fake notifier unavailable | Stop notification retries and retain visible failure | Three fake attempts; saved event retained and notification marked failed |
| Fail between the accepted-row and outbox writes | Roll back both writes | Injected 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.
| Decision | Record before implementation | Evidence to inspect later |
|---|---|---|
| Intended outcome | Source, destination, fields and owner of the final record | Versioned input/output mapping and saved synthetic record |
| Allowed caller | Roles, permissions and expired/denied-access behavior | Permitted and denied journeys in the actual authorized test environment |
| Repetition | Operation identity, retention and conflicting-input rule | Equivalent replay, conflicting replay and relevant business-duplicate cases |
| Uncertain result | Status lookup or reconciliation owner before any new creation | Saved record plus the caller’s uncertain/recovered state |
| Notification | Separate accepted, pending, sent and failed meanings | Destination acknowledgement, retry cap and recovery evidence |
| Operations | Support owner, incident visibility and handover requirements | Agreed 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.
| Synthetic input | Proposed destination | Decision required before implementation |
|---|---|---|
event_id | Receipt reference | Define the provider's event identity, retention period and conflicting-payload rule. |
booking_id | Business booking reference | Decide when a later event updates one booking and when it represents a separate action. |
customer_ref | Permitted customer reference | Agree the source of truth and permitted lookup; keep private customer data out of examples. |
seat_count | Requested quantity | Define the type, allowed range and correction path. |
| Source revision or timestamp | Reconciliation context | Decide how an older event is identified and whether it may change a newer record. |
| Destination record ID | Caller reconciliation reference | Define 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.
Related development services
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