AI runs the operation. You run the relationships.

Today, quoting is a day spent in tabs.

Every renewal involves a panel of insurers, and every insurer has its own way in. Some prefer email, with a structured template they expect back filled out a specific way. Others only accept submissions through their broker portal — each with their own login, layout, and quirks.

So the administrator's day is fragmented. They open seven tabs, re-key the same scheme into half of them, draft chase emails into the others, paste quotes into a comparison spreadsheet that's already out of date, and try to keep track of which insurer is at which step.

By the time the quotes are all in, they're in four different formats — and the proposal still needs building.

One pipeline. Every insurer, every method.

Tendr orchestrates the entire panel from one place. The administrator picks the insurers and products in scope; the AI determines how each carrier wants to be approached, dispatches the request, tracks the response, and brings everything back into a single comparable view.

Email-friendly carriers get a structured email and an attached submission. Portal-only carriers get an AI agent that logs in, fills the form, and submits. The administrator sees one pipeline status — not seven tabs.

The client data feeding the run can be uploaded directly — or piped straight from the Intelligent Client Data Collection feature, so the same dataset that the client filled in flows through the quoting engine without anyone re-keying it.

Quote requests, drafted and dispatched by the AI.

For email-accepting insurers, the AI composes the request — subject, body, the right contact, the right attachments — and sends it. The administrator never opens a draft.

Follow-ups happen automatically. Chase logic is baked in: if a carrier hasn't responded by the SLA, a follow-up goes out. If the response is partial, a clarifying reply is sent. Every interaction is logged against the case.

Where a carrier comes back with something the AI genuinely can't resolve on its own — an unexpected schema, a referral query, a non-standard SOR check — the case is escalated to an administrator with the full thread attached and a focused recommendation on how to proceed.

For portal-only insurers, an AI agent drives the browser.

Many carriers still require new business through their broker portal rather than via email. The agent signs in, navigates to the right form, fills every field from the underlying dataset, and submits — exactly as a human administrator would.

Every action is recorded; the administrator can replay any session and see what was submitted, when, and to where.

Every response normalised into one comparable view.

Quotes come back in every shape imaginable — PDFs, email bodies, portal exports, structured JSON. The AI reads each one, extracts the premium, the cover, the excess, the terms — and lands them all into the same comparable structure.

The cheapest landed price is identifiable at a glance. The best-fit cover is identifiable at a glance. The administrator stops carrying the comparison in their head, or in a brittle spreadsheet.

A branded, client-ready proposal builds itself.

Once quotes are in, Tendr populates your branded proposal template with the recommendation, the comparison table, the pricing, and the terms. Your tone, your logic, your output — assembled automatically.

The administrator reviews and sends. The document the client sees is the document the administrator would have built — just without the two days in Word.

Today, every renewal starts with a chase.

Group cover starts with data — DOBs, postcodes, salaries, dependants — and clients deliver it in whatever format their HR system happens to spit out: mismatched columns, dates in three different styles, salaries in “k”, postcodes left blank.

The broker administrator absorbs most of it manually — reformatting spreadsheets, normalising columns, filling in gaps from memory or previous submissions. Hours disappear into the cleanup. When the data is too far gone, the only option is to send it back to the employer and ask them to redo it.

Even with all that effort, errors still slip through. The insurer catches what the admin missed, the submission gets rejected, and the chase begins again. By the time the dataset is clean enough to underwrite, the renewal window is half-spent.

One link, any format, insurer-ready on the other side.

Tendr generates a branded, password-protected collection page for the employer. They upload whatever they have — a messy spreadsheet, a scanned PDF, a screenshot, even a forwarded email body. No template to fill in, no field-mapping to learn.

Our AI reads what came in, infers the context, and validates it against each insurer's schema — Bupa, Zurich, Aviva, AXA, Canada Life, Legal & General, WPA, Vitality and the rest of the market. The same upload yields a submission-ready dataset for every carrier you've quoted, side-by-side and one click to send.

Tell us the carriers. The schema assembles itself.

Every carrier has its own quirks — Bupa wants postcodes, Zurich wants cover multipliers, Canada Life cares about smoker status, and every other insurer has their own list. Configuring a submission used to mean reading underwriting packs, scanning past submission templates, and asking other people on the team which fields each carrier expects this year.

With Tendr, the broker just picks the insurers and products in scope. The schema is built from the union of every carrier's requirements, deduplicated, and ready to drive the client's collection page.

A secure, password-protected page, built in one click.

The schema becomes a live, branded collection page with a unique password. The link sits behind authentication; the password is sent separately. Clients meet a page that looks like part of your service, not a third-party tool, and upload whatever they have.

Every link is time-limited, every submission is encrypted in transit and at rest. No template downloads. No “please use this version” replies.

Whatever the client sends, we standardise it.

CSV, Excel, PDF, a screenshot from an HR system, a paragraph of free-text in an email body — Tendr parses the content, identifies the fields, and normalises every value into the insurer-ready schema.

DOBs in three different formats become ISO 8601. “38k” becomes £38,000. Postcodes inferred from address text get validated against the Royal Mail format. Every transformation is explainable; anything ambiguous is flagged rather than guessed.

Last year carries over. Only the changes need confirming.

At renewal, last year's dataset is pre-populated and the client is shown a focused diff: joiners, leavers, salary updates, any material change. Everything else is one click to confirm-as-is.

What used to take a fortnight of re-collection becomes a five-minute review — for both the broker and the employer.

Insurer-ready datasets, one click away.

The same source dataset produces a submission in whatever shape each carrier expects — a Bupa-formatted XLSX, a Zurich CSV, a Canada Life form pack, and the equivalent for every other insurer the broker works with. The administrator picks “Send” and Tendr handles the rest.

Manual attachment, manual portal entry, manual reformatting all collapse into a one-click submission step.

Onboarding starts with a stack of reformat work.

Every implementation starts with data that doesn't match the platform's template. Employer HR exports look one way, insurer membership lists look another, last year's rollover sheet looks a third — and none of them line up with the structure the platform actually needs.

So the administrator opens Excel and starts re-keying. Find-and- replace passes, column renames, format normalisation, missing field backfills — hours of careful work before a single member can be enrolled, and a steady drip of errors that only surface days later when something downstream breaks.

Drop the file in. The AI does the work.

Tendr accepts whatever the administrator has — Excel, CSV, scanned PDF, a forwarded email — and does the work end-to-end: it maps source columns onto the platform's template, normalises every cell to the right format, validates against the schema, and lands the rows ready to commit.

The AI understands the full context of the policy, the source documents, and the data it's working with — and resolves the vast majority of cases on its own. The administrator only comes in for the small set of cases where the AI genuinely doesn't know — a piece of context that only the team has — and the AI applies their answer cleanly across the dataset.

Source columns find their home — automatically.

The AI reads each source sheet and works out what every column is, even when the headers are non-standard, units are wrong, or rows are interleaved with blanks. It writes the mapping itself — “Email Address” into email, “Annual Pay (£)” into salary, “Home Postcode” into postcode, and so on — and stamps each match with a confidence rating.

What used to be a hand-built mapping spreadsheet — kept up to date across every employer and every renewal cycle — becomes a one-shot operation.

Just the things the AI can't decide.

For the vast majority of cells, the AI knows what to do and just does it. For the few that are genuinely ambiguous — a date that could be DD/MM or MM/DD, a member who matches two records, a category the source uses that isn't in the schema — the chat surfaces a focused question and a couple of one-tap answers.

The administrator answers a handful of yes/no calls instead of opening Excel and clicking through 287 cells.

One click. Members enrolled.

Once every question is answered, the AI commits the rows directly into the platform's onboarding flow. Member records, cover allocations, effective dates and the audit trail all write together — no re-export, no second pass, no downstream cleanup.

The records that land are validated, normalised, and structured the same way every time — so reconciliation, reporting, and member servicing all sit on a consistent base.

Day-to-day admin is a queue that never empties.

Joiners. Leavers. Dependants added. Cover upgraded. A scheme change here. A correction there. Every client, every day — small admin tasks land in the team's queue from employers, members, and insurers themselves.

Each one means picking the right insurer's channel, drafting the right structured email or logging into the right portal, waiting for confirmation, and remembering what was done weeks later when a question comes back. Multiply by every client on every day, and most of the admin team's week disappears into it.

And while the queue backs up, the member is the one waiting — days or weeks for a joiner to be enrolled, for a dependant to be added, for an upgrade to land. Service quality scales with how fast the admin queue moves, not how good the underlying cover is.

An AI agent that runs the queue end-to-end.

Tendr's admin agent picks up each task as it arrives, identifies what it is, picks the right insurer channel, and runs the workflow through to confirmation. Email-based requests get drafted and sent; portal-based requests get an in-browser agent that signs in and does the work.

Because the agent never sleeps and never builds a backlog, changes get processed as they land — joiners, leavers, dependant additions, upgrades. The member is enrolled, removed, or upgraded the same day rather than waiting days or weeks for the admin queue to clear.

Genuine edge cases are escalated to the administrator with full context so they can resolve them in a sentence. Everything else runs without anyone touching it — and every action is recorded, attributable, and replayable.

Admin requests, drafted and dispatched.

For carriers that accept email-based admin, the AI composes the request — joiner add, leaver, dependant, upgrade — with the right structure, the right reference, the right effective date, and the right contact. Sends it, tracks the response, and follows up on SLA without prompting.

The administrator never opens a draft for a routine joiner or leaver again.

For portal-only insurers, an AI agent does the clicking.

Many insurers require all member changes to happen inside the broker portal. The agent signs in, finds the scheme, opens the right form, fills it from the underlying member record, and submits — exactly the way an administrator would, only faster and at any hour.

The administrator can watch the agent work in real time or just see the confirmation land in the audit log.

When judgement is needed, the AI brings you in.

A duplicate member across two clients. A change request that wouldn't hold up at underwriting. A leaver date that conflicts with an outstanding claim. The AI doesn't guess on cases like these — it pauses, surfaces the context, lists the routes it can take, and waits for an experienced administrator to pick one.

Escalations aren't a hand-off. They're a fast, focused question — the AI does the discovery, the administrator just makes the call, and the AI carries it through.

Every action logged, attributable, replayable.

Every email drafted, every portal click, every approval given, every response received — captured with timestamp, actor, channel, target, and reasoning. The audit log is the same source for compliance reviews, training, dispute investigations, and end-of-month reconciliation.

Replay any case and see exactly what the AI did, what the response was, who approved what, and when — without piecing it together across three inboxes and a portal history.

Records drift apart silently.

Members get added, dropped, upgraded, or have their cover changed — directly on insurer portals, outside our platform. The administrator only finds out weeks later, when a commission report doesn't balance or a member queries cover they shouldn't have.

Reconciliation used to be a quarterly spreadsheet exercise: pull a report from each carrier, paste it into a comparison sheet, work through the diffs by hand. Most months it didn't happen at all — and the gap between Tendr's records and the carrier's kept widening.

A reconciliation engine that never sleeps.

Tendr runs a continuous reconciliation pipeline against every connected carrier. Carriers that expose a broker portal get pulled on a schedule by an AI agent. Carriers that don't get a structured email request from the same agent on the same cadence. Either way, the data lands and gets compared.

Routine drift is fixed automatically. Anything that needs a human call is escalated with full context and a focused set of options the AI thinks are worth considering.

The agent pulls the report like an administrator would.

For carriers with a broker portal, the AI agent signs in, navigates to the right scheme and report, generates the latest membership extract, and downloads it — exactly the way an administrator would, only without anyone clicking.

Each pull is captured in the audit log: which scheme, which period, which file, when, and what came next.

For carriers without a portal, the AI asks for the data.

Some carriers don't expose a broker portal at all — and others have one that's flaky or partial. For those, the agent drafts a structured monthly request, sends it to the carrier's admin desk, follows up on SLA, and reconciles whatever they send back.

The administrator doesn't draft these emails. They don't chase the replies. They just see the result land in the platform.

Insurer report, Tendr records, side by side.

Whatever shape the carrier's report arrives in — CSV, XLSX, portal export, scanned PDF — the AI parses it into the same structure as the platform's records. Matches, mismatches, and one-sided rows are visible at a glance.

Cover tier changes, salary upticks, joiners on the carrier the platform doesn't know about, leavers on the platform the carrier doesn't — every divergence comes out as a categorised finding the AI can act on.

Routine drift fixed automatically. Edge cases brought to you.

Salary updates, postcode tidies, cover-tier renames, joiner-leaver mirroring — the AI applies these to the platform automatically, and logs every change against the reconciliation run that produced it.

For the genuinely ambiguous — a member on the carrier we don't have, a record on ours that's vanished from theirs — the AI surfaces the case with full context and the routes it thinks are worth considering, or a free-text option to say something else. The administrator picks, the AI carries it through, every step captured.

Members wait days for answers that are already in the policy.

Repeat questions land in the admin team's inbox every day — what's the excess, what does my cover include, how do I add a dependant, how do I claim. The answers are sitting in the policy documents, but a member has to wait for a human to read them and reply.

A large share of inbound queries are FAQs in disguise — and they all sit behind a human queue. Members get a slower experience; the admin team spends most of its week on questions a system could answer in seconds.

An AI assistant in the member app.

Tendr's support chatbot lives inside the member app. Employees ask plain-language questions about their benefits and get an immediate, conversational answer — drawn entirely from approved policy documentation and FAQs the team has uploaded.

Every answer is cited inline: the document it came from and the section it sits in. If a member wants to dig deeper, the source is one tap away.

Source-grounded · regulated advice off-limits.

The bot is deliberately constrained. It can only answer from the documentation it's been given — and it's explicitly prevented from offering regulated financial or insurance advice. Questions like “should I switch up a tier?” or “is this worth it?” are politely declined and routed to a human.

Everything else — what's covered, how the excess works, how to claim, how to add a dependant — gets a clear, sourced answer in seconds.

When a human is needed, the AI invites them in.

Some questions need a human call — policy interpretation, sensitive member situations, anything outside the bot's approved scope. For those, the AI summarises the context and invites an administrator into the same chat with the member, with the member's details and the question history attached.

The administrator joins from a notification, picks up where the AI left off, and replies directly to the member — no copy-paste from another inbox, no missing context.

Every conversation, visible to the admin team.

The admin dashboard lists all member conversations across every scheme. Each row shows the member, the scheme, the last message, the status (AI-handling / live with admin / awaiting / resolved), and a Jump-in button to step in at any moment.

Compliance reviews, training, and quality audits all draw from the same set of fully-logged transcripts — every cited source, every admin handoff, every action captured.

Most brokers don't know what they're owed.

Commission lands every month from every carrier — and every carrier sends it in a different shape. Bupa drops a single bulk PDF. Zurich sends one Excel file per client. Canada Life gives totals only. L&G pastes a CSV into an email body. MetLife exports forty-seven columns of which six are populated.

Reconciling it is a monthly spreadsheet exercise that most brokers either skip or do shallowly. Underpayments, missing receipts, and rate mistakes accumulate quietly — and revenue leaks.

An always-on reconciliation engine, statement to bank.

Tendr ingests every statement automatically, parses it into a normalised structure, matches each row back to the policy on the platform, calculates what should have been paid, compares it to what the carrier said they paid — and to what actually landed in the broker's bank.

Routine variances become drafted recovery emails. Larger or ambiguous cases land on the administrator's desk with full context and a recommended call. The monthly report is finished before anyone asks for it.

Any statement, any shape, parsed in seconds.

Bulk PDFs, per-client Excel exports, summary-only spreadsheets, CSV-in-the-email-body, raw exports with twice the columns they need — the AI reads each one, pulls out the rows that matter, and writes them into one comparable structure.

Nobody rebuilds a comparison sheet. Nobody hand-keys totals. Nobody waits for the “clean” version that never arrives.

Expected, statement, and bank-truth — side by side.

Once the rows are normalised, Tendr lines them up against the platform's policy records to calculate the expected commission. Brokers can optionally connect their bank via open banking to add a third column — what actually arrived — so any missing receipt surfaces against the statement that should have triggered it.

Missing receipts surface in days, not at year-end. Statement-only underpayments stop hiding inside reasonable-looking totals.

Month-end finishes itself.

The reconciliation report builds itself as statements arrive: per-carrier rollups, shortfall totals, overpayments, status per case, and recovery work in flight. It's ready to share with finance the moment the last statement lands.

Compliance reviews, year-end checks, and broker payouts all draw from the same set of fully-logged numbers — no rebuilds, no guesses.

The AI features run beautifully. The glue between them is still you.

Each AI feature on the platform handles a single piece of the day beautifully — but the journey across them, the order they run in, and the human signals between them are still improvised. Someone remembers to start the next step. Someone copies a reference into a ledger. Someone messages the scheme owner.

Standard, off-the-shelf workflows don't fit, because no two brokerages route work the same way. The features stop being a force multiplier and start being seven smart tools an administrator manually queues.

The AI features become a kit. You build the workflow.

Custom Workflow Design is a collaboration: we sit alongside your team, map the journeys you actually run, and wire the platform's AI features into them. Tendr builds the workflow with you — the actions one of the features already performs, composed in the order, with the approvals, and with the comms your operation actually uses.

The workflow runs end-to-end. The administrator approves what needs approving, and watches the rest happen.

Start on schedule, on an event, on a signal — or on demand.

Every workflow begins with something. A regular timetable for the month-end commission run. A joiner uploaded by the employer. A quote that just came back from the carrier. A nudge from an HR system. A button somebody on your team presses for a one-off rerun.

Whatever fits the work — the trigger gets configured once, and the workflow runs itself from there.

Email · Teams · Slack · PDF · ledger · wherever the work lands.

Workflows finish at people, channels, documents and systems. The same workflow can email the member, post to a Teams channel, ping Slack, generate a branded PDF, and write a row into the broker's ledger — all from the same run.

The team gets the signal where they already look. The audit log gets every action.

Migration is why most projects stall.

Brokerages have years of records in their existing CRM, their practice-management suite, an old bespoke database their founder built, and a SharePoint folder of insurer dumps. The thought of moving all of that onto a new platform is enough to shelve the whole AI conversation.

Most rip-and-replace projects ask for a ten-week disruption — data freezes, retraining, hand-mapped schemas — before any AI feature delivers a single hour of value. Most teams never start.

We don't replace your CRM. We read from it.

Our onboarding agent connects to every source you already run — CRM, practice management, document libraries, bespoke databases, insurer feeds — and uses what it finds to seed the Tendr platform alongside them. No CRM gets switched off. No team gets retrained.

The agent reads what's there. The Tendr workspace fills up. The existing systems keep running.

Any CRM, any CMS, any bespoke system — we read it.

Salesforce, HubSpot, Microsoft Dynamics, Pipedrive, Zoho. Acturis, Open GI, Applied, EPIC, BrokerLink. SharePoint, Drive, Dropbox, S3. Postgres, SQL Server, Oracle, custom REST endpoints. Insurer membership exports, commission statements, claim dumps. Even forwarded emails with CSV in the body.

Every category below is a connector the agent already supports — and the list grows with every implementation we run.

Records appear in Tendr without anyone re-keying them.

As the agent reads each source, it scaffolds clients, schemes, policies, and members directly into Tendr — normalising fields, matching records across sources, and linking members to the right policies. Where the carrier's feed is enough to structure a scheme on its own, the agent uses that and doesn't even look at your CRM.

Where the agent isn't sure — a record that could match two clients, a category it hasn't seen before — it surfaces the case to be resolved before the seeding continues.

Your CRM stays live the entire time. No freeze, no cutover weekend.

Across the four to five weeks of onboarding, the existing CRM accepts live updates as it always has. Tendr is read-only at this point — it's being seeded, not relied on. The team carries on as normal.

At the end of the run, the AI workflows go live because every record they need already sits inside Tendr. No data freeze, no cutover weekend, no operational disruption.