Implementing a lead collection bot in a mobile app

In-app lead collection bot: where requests get lost

An in-app lead collection bot breaks not when sending a message, but at the junction between the screen and the server. The user backgrounds the app, the network switches to a weak channel, the process is unloaded by the system — and the completed form remains in local storage.

Meanwhile, the screen already says “Sent,” because the interface reacts to the tap, not to confirmation of the record.

In our measurements on a typical project, 12–18% of submissions never reached the database.

The gap is invisible in reports: form conversion is counted by click, while lost in-app requests are revealed only by reconciling with the database and logs — usually months later, when the flow of requests has already declined.

The causes repeat: the event is sent in a single request, without a queue or retry; the request identifier is generated on the server, so there is nothing with which to restore an interrupted request; and there is no confirmation from the bot that the request was registered. Anything that does not arrive disappears without a trace.

External analytics such as AppsFlyer shows clicks and installs, but does not prove that a request made it into the database. In our projects, the discrepancy between the counter on the device and server records reached 8–12% — and it can only be closed on the app side.

Below we break down how this is closed: an event queue on the device, retry when connectivity returns, and server-side acknowledgment of receipt.

What changes after implementation: measurable effects

The effect of a lead collection bot is visible not in the number of button taps, but in the gap between “the user submitted it” and “the manager started working on it.” We capture five metrics before and after launch — and they also become the acceptance procedure.

• Share of requests that arrive. Submission is no longer tied to the active screen: the bot queues it and retries when connectivity is restored, so the request does not disappear when the app is closed or the network drops. The share of forms that reach the manager grows from 60–70% to 90%+.
• Response time to a request. The first reply and qualification are sent automatically at the moment of submission; the manager receives an already tagged contact with a history of steps. Response time shrinks from hours to minutes — 2–5 minutes versus 40–60.
• Class of lost requests. An entire layer of “lost in the conversation” disappears: every request has an owner and status, and stalled ones are raised by a reminder.
• Repeat contacts. If the user has not left a contact, the scenario brings them back through a useful step rather than a second pop-up — repeat touches become a manageable quantity, not an accident.
• Transparency of the user journey. Funnel events are collected step by step, and accumulated statistics in Amplitude show on which screen the bulk drops off. Changes are made based on data, not guesses.

We measure everything on one set of events — before and after, so the comparison is correct.

Bot connection options: comparing modes

The connection mode determines where the bot logic lives and who holds the dialogue state. The built-in module puts processing inside the app — it works offline, but updating the scenario requires a new build, and some users will not install it.

Modes and their limits

An external service and a proprietary server-side request handler move logic outside the client: scenarios change without a release, but a dependency on the communication channel appears, along with protection against resubmitting the same request.

A scenario builder closes typical branches quickly, but hits the platform ceiling when logic based on in-app data is needed.

The choice is rarely binary: often the built-in module collects the initial contact, while the server-side request handler validates and routes the request.

We analyze the data flow and failure points, then lock in the mode — and change it without rewriting the app if the scenario outgrows its original scope.

Implementation stages: from audit to handover

Implementing a lead collection bot inside a mobile app is not installing a ready-made module, but working with contact points, permissions, and data.

Below is the order in which we run a project: each stage ends with a verifiable artifact that can be accepted or challenged before anything goes to production.

1. Audit of collection points. We analyze current screens: where the user already enters a contact, where they abandon the form, which app events are actually tracked. The output is a map of collection points with priorities: which we connect first, which duplicate each other, which should be removed.
2. Data transfer scheme. We agree on which fields go to the external system, in what form and at what frequency, and what to do when the receiver is unavailable. We record the scheme in a document: sources, fields, matching rules, and retry behavior.
3. Scenario and permission setup. We assemble the dialogue logic: launch triggers, response branches, conditions for transfer to an operator. Separately, we describe permissions — who sees requests, who changes the scenario, who exports data.
4. Scenario testing on live traffic. We enable collection for part of the audience and look at real sessions: the share reaching contact, drop-off points, false triggers. We make changes based on data, not assumptions.
5. Acceptance. We compare the result against agreed criteria: completeness of transferred requests, no losses during failures, correctness of source tagging. We close errors before handover, not after.
6. Handover of procedures. We provide the scenario description, editing rules, support instructions, and incident response procedure. The client’s team then changes texts and conditions independently, without contacting us for every minor detail.

Handover kit: schemes, rules, documentation

A lead collection bot remains a working tool as long as it can be changed without us.

Therefore, by launch we assemble a handover kit — not only the scenario, but everything needed so that your team or another contractor can make changes, without reverse engineering and correspondence with the authors.

• Scenario configuration — a tree of steps with branches, texts, and transition conditions in editable form: a survey question or qualification threshold changes without rebuilding the app.
• Data flow scheme — the path from a touch in the interface to a CRM record: which fields are sent, where they are enriched, where duplicates and incomplete requests are filtered out.
• Access rules and roles — who edits the scenario, who sees exports, who sees only statistics; keys are separated into test and production environments.
• Event and metric reference — share completing the survey, step-by-step drop-off, lead source, with a single interpretation for both sides.
• Support procedure — channels and response time by failure class: lead not sent, integration unavailable, text error; with an owner on each side.
• Instructions for edits and rollback — how to test a change in the test environment, how to roll out and how to revert to the previous version if a metric drops.
• Decision log — why these qualification conditions and repeat-touch windows were chosen: during the next enhancement, the logic will not have to be reconstructed from memory.

Case study: how restructuring the scenario brought requests back

The client came with an app where the lead collection bot formally worked: the form opened, the request was sent, a checkmark appeared in the report. But only part of the requests reached the manager, and no one could say at which step the rest were lost.

Where requests were lost

Analysis of logs and session recordings showed three bottlenecks. First — the phone request immediately after the survey: some users interrupted input, the draft was not saved anywhere, and the person started over or left.

Second — notifications were sent only during working hours, so evening requests waited until morning. Third — the invitation to continue the dialogue led to Telegram, but the manager’s reply did not return to the app: the user thought the request had been lost.

What was changed in the scenario and rules

The survey was split into steps with each saved separately — returning is possible from the same place, even after closing the app. The phone request was moved to the end, when the value is already clear.

Routing was tied to time zone and shifts: the notification goes to the responsible person immediately, and after 10 minutes of silence it escalates to the next one. The conversation was synchronized between the app and the messenger so the history would not break.

After the changes, the share of requests that arrived grew from 41% to 74%, and response time fell from 5 hours to 6 minutes. A separate funnel report was assembled — loss at any step is now visible on the first day, not at the end of the month.

How does a built-in request module differ from an external service?

The difference is not where the form is drawn, but who is responsible for delivering the request. The built-in request module saves the request in the app’s local storage, queues it, and sends it to our server on the first stable network.

An external service receives data directly from the app: it connects faster, but the channel to it becomes a single point of failure.

Failure resilience is the main dividing line. The built-in module survives a poor network, app closure, and session interruption: the request will be pushed through on the next launch, and duplicates are filtered out by the identifier generated on the device before submission.

A mixed option is reasonable when the app is the main lead channel, but marketing needs third-party mailings and analytics. Then our receiver remains the source of truth, while an export goes to the external service: if it is unavailable, requests accumulate locally and go later. Describe the scenario — we will come back with an estimate and plan.

Technical questions: addressing common doubts

Doubts at acceptance are almost always the same: how much will have to be touched in the existing app, what will happen to repeat touches, where will the already collected funnel go, how to make sure that not a single request is lost, and what remains with the team after handover. Below are short answers to each.

What to do with duplicate contacts?

Deduplication is based on a stable identifier — phone number or email address — with additional matching by device identifier. A repeat request supplements the existing card rather than creating a second one, and the history shows which touch was first.

We already have a scenario deployed — will we have to throw it away?

No, we connect the working scenario as a separate branch. If it lives in another tool, we set up the exchange: triggering, transfer of request fields, return of processing status. The logic that already brings in requests continues to work.

How can we verify that requests are not lost?

We reconcile the flow at three levels: the event in the app, receipt on the bot server, and recording in the request storage. We run test paths with network interruption and retry — with successful server responses everything arrives, and discrepancies are visible in the log.

What remains with us after handover?

The flow scheme, event list, deduplication rules, scenario editing instructions, and monitoring access. After that, support follows the agreed procedure: scenario edits, failure analysis, and request delivery control.

Let’s discuss the task: how we start work

So that the estimate and work plan are based on facts rather than assumptions, one conversation and a minimum of inputs are enough for us.

A lead collection bot lives inside the app, so both current analytics and how the user journey is structured matter: where registration is, what happens after first launch, and where requests go today.

It is useful to include with the request:

• a description of the scenario: at which step the user leaves a contact and what they receive in return;
• current points of request loss — screens and steps after which a person closes the app;
• access to analytics or a funnel export for the last period;
• a list of channels where requests currently go: email, accounting system, messengers, spreadsheets;
• data requirements — which fields we collect, who processes them, and whether transfer to an external system is needed;
• constraints: notification rules, personal data storage, app store requirements.

In response, you will receive not a general proposal, but an estimate and work plan: a scenario scheme with collection points, the composition of integrations, a list of changes in the app and on the services side, the order of rollout by stages, and how the result will be measured — the share of completed contacts and the volume of lost requests before and after.

Describe the task in a convenient form — we will come back with an estimate and plan, timelines by stage, and a list of what will be required from your side.