TL;DR: Score the conversation separately from the work that runs after the call ends: EHR updates, notes, callbacks, escalations and recovery jobs. Give each stage its own assertion, a correlation ID that ties it to the same call, and a completion window. Report each result as passed, failed or unknown. Unknown means the evidence is still pending or missing. A clear spoken confirmation does not prove the record was written. Ship Voice, from ContextQA, the autonomous quality engineer, verifies the conversation, the action and the business outcome.
A voice agent test that stops when the caller hangs up never checks post call automation, so defects in that work can go unnoticed. The caller heard "you're booked," but the electronic health record (EHR) update, callback or escalation may arrive late, fail or never run. This guide shows how to score the conversation, the tool action and the authoritative record separately, with completion windows and an explicit unknown state.
Quick answers
How long should a test wait for a post call task to finish? Use a completion window that you agree on with the process owner for each stage. Record the timestamp when the call ends, then poll the record under a bounded policy. If correct evidence arrives inside the window, the stage passes. If the record is still missing at the deadline, the stage is unknown, not passed. That is a different result from a record that was written incorrectly.
Why score the conversation separately from the workflow? An agent can confirm every detail correctly while the booking, CRM update or escalation it promised never gets written, or gets written wrong. Treat the spoken promise, the tool response and the authoritative record as three separate assertions. Then one passing check cannot cover for one that failed, and a wrong date cannot get averaged away.
How do you make sure a test checks the right downstream record? Give each test interaction a correlation identifier, such as a call ID or booking ID, and link it to every downstream note, case or notification. Fetch records with a read only verifier that looks them up by that identifier, never by the newest entry. The verifier must never create or repair a missing record.
What is post call workflow testing and when do you need it?
Testing post call automation means verifying the work that a voice or chat agent triggers after the conversation ends. That work includes EHR (electronic health record) updates, call notes, callbacks, escalation tickets and recovery jobs. You need it whenever a call can end with a spoken promise that a separate worker or downstream system has to fulfill minutes or hours later.
This work runs asynchronously, so a clean transcript tells you nothing about the record. Score three things separately: the conversation, the tool response, and the authoritative CRM, database or EHR record. Tie each one to the same call ID. Give each stage a completion window and an explicit unknown state so a pending task never counts as a pass (ContextQA end to end outcomes guide).
Ship Voice runs an Outcome model on every call. Before a call is marked resolved, the model confirms in the system of record that the problem was actually solved.
What do you need before you start?
You need four things before you write the first assertion:
- A stage table that lists each post-call task and its expected state.
- A correlation identifier that ties every record to one call.
- A completion window for each task.
- Read only access to the system of record that holds the result.
Without these, a pending job looks the same as a failed one.
The main decision is how to collect the evidence. The end to end outcomes guide describes three approaches:
| Option | Best for | Setup needed | Tradeoff |
|---|---|---|---|
Read only REST or Lambda Verifier | Records that exist before the run ends | Scoped read endpoint | Must never create a missing record |
| Separate downstream worker case | Notes, EHR writes and recovery jobs that finish later | Conversation as approved input, plus expected outcome | Does not prove the trigger fires |
| Orchestration test | Showing the real end of call event starts the worker | Event access in a test environment | Says nothing about record correctness |
Use a Health check probe to confirm readiness. Use a Pre-Run Environment Hook only for authorized setup.

How do you test delayed post call work step by step?
Treat each downstream task as its own result: the conversation, the primary action, and every delayed job such as an EHR note, callback or escalation. Correlate the evidence by call ID and give each task a completion window. Report passed, failed or unknown. A finished call is not proof of a finished workflow.
- Build a stage table. For each task, list the expected fact, the correlation ID and the completion window.
- Score the conversation on its own. Give each requirement its own pass and fail criterion so a clear readback cannot hide a wrong date (booking outcomes guide).
- Check summary accuracy. Compare the generated note with the final corrected values in the transcript. A fluent summary that drops a correction fails.
- Verify persistence read only. Look up the record by call ID, never by "latest record." Never let the check create the missing note.
- Poll within a fixed window. The example below polls your own read only endpoint, not a ContextQA API. When the window expires, it skips the test, so an unknown result never counts as a pass:
import { test } from '@playwright/test';
test('post-call EHR note matches final request', async ({ request }) => {
test.setTimeout(16 * 60_000);
const url = `${process.env.EHR_READONLY_URL}/notes?callId=${process.env.CALL_ID}`;
const deadline = Date.now() + 15 * 60_000; // window from the stage table
let outcome = 'unknown';
while (Date.now() < deadline) {
const res = await request.get(url);
if (res.ok()) {
const note = await res.json();
outcome = note.appointmentDate === '2030-05-30' ? 'passed' : 'failed';
break;
}
await new Promise((r) => setTimeout(r, 30_000));
}
test.info().annotations.push({ type: 'postcall_outcome', description: outcome });
test.skip(outcome === 'unknown', 'No note inside completion window');
if (outcome === 'failed') throw new Error('Stored date differs from final corrected date');
});
What are the most common mistakes?
Six mistakes can turn a delayed EHR note or callback job into a false verdict that a release decision then depends on. They are: scoring the call and the workflow as one result, checking the latest record instead of the correlated one, skipping the completion window, scoring missing evidence as a fail, letting the verifier repair state, and testing the worker without its trigger.
- One verdict for the call and the workflow. This hides a clean call that produced no CRM update. Fix: one assertion per stage.
- Querying the newest record. This picks up another run's note or booking. Fix: match on the call ID or booking ID.
- No completion window. Slow jobs get flagged as defects. Fix: log the call end time and poll within a set limit.
- Missing evidence scored as failed. This hides pending recovery jobs. Fix: an explicit pending or unknown state.
- A verifier that writes data. The verifier hides the defect by fixing it. Fix: a read only
Verifier. - Testing the worker alone. A broken end of call trigger goes unnoticed. Fix: a separate trigger test.
Webhooks that fire into telephony or CRM systems after a call ends need the same discipline. Assert that the event fired and that the downstream record exists and matches, and check both against the same correlation ID.
How do you know it is working?
It is working when every completed call produces linked, verified evidence for each later stage within its completion window, and pass, fail and unknown counts are reported separately. A green conversation score next to an unverified EHR note is not a pass. Track the unknown rate as its own number and push it toward zero.
Run these checks on each scenario:
- Score the conversation on the caller's final corrected request, not on the first values spoken.
- Link each note, callback or escalation to the same call ID.
- Record the call end timestamp and the window. Evidence that arrives late does not pass, and evidence that never arrives stays unknown.
- Prove that the real end of call event triggers the worker, in a case separate from the worker test.

How do you automate post call checks with ContextQA?
Ship Voice keeps the recording, transcript and outcome of every call. Its Outcome model confirms in the system of record that the problem was solved before the call is marked resolved. For delayed work, score the spoken promise, the tool response and the eventual EHR or CRM record as separate assertions, and treat missing evidence as its own state.
- Map the stages. Give the conversation, booking, note, escalation and callback stages an expected fact, a correlation identifier and a window each.
- Verify read only. Configure a REST or Lambda Verifier that fetches records by call ID or booking ID.
- Bound the wait. Mark each stage passed or failed. If evidence is still pending or missing at the deadline, mark it unknown.
- Split the worker. Test the downstream job as its own case, and test the trigger as a separate case.
Before each release, run a pre-deployment baseline tied to the agent revision, and turn incidents into sanitized regression cases.
If your voice agent says "done" while the EHR note, callback or escalation is still pending, see how Ship Voice scores the call and the final outcome separately. Book a demo to see your workflow verified.
What should you do right now?
This week, pick one post-call workflow and write out its stages. Score three things separately: what the agent promised, what the tool returned, and what the system of record holds when the window closes. Add an explicit unknown state so a delayed EHR note or a missing callback can never pass by default.
- List every stage that runs after the call ends for one workflow, such as a booking and its note.
- Assign correlation IDs: call ID, booking ID, note ID and case ID.
- Agree on a completion window for each stage with the process owner.
- Seed synthetic, anonymized patients or customers in a sandbox EHR or CRM. Never replay real recordings.
- Mock only the dependencies you don't own, such as SMS delivery. Keep the record you assert on real.
- Script personas that make corrections, like "actually, Thursday."
Bottom line
A voice agent finishing a call does not prove the workflow finished. Score the spoken promise, the tool response and the authoritative CRM, database or EHR record separately. Give notes, callbacks, escalations and recovery jobs their own completion window and an explicit unknown state. On Monday, write a stage table for one critical flow with a correlation ID on every stage. Then try Ship Voice.