How Bridge works

This is Kipso Bridge.

It takes the messy files a school district already has,

and gets them ready for the system the district already uses:

loaded straight into Kipso, or prepared for another system’s own import tools,

with a guide and a check afterwards.

Here’s how it works, with Maple Hollow, a fictional district.

Step one: the files.

A budget workbook, a staff list, contracts, a pay application,

an accounting export, and a change-order log from an old system.

They’re messy on purpose: three spellings of the same fund,

mixed date formats, and a subtotal that’s twenty-five thousand dollars off its

own lines. Bridge reads each one and says what it found.

Step two: where it’s going.

A project system, like Kahua or Procore, or an accounting system,

like Munis. Bridge loads straight into Kipso.

Every other destination here is a simulation, built from public documentation;

in real use, those get an import package instead.

Bridge first reads the destination’s own setup: its required fields,

its pick lists, its numbering.

And it says plainly what it can’t see in advance.

Step three: the mapping.

Every match comes with a confidence score and the reasoning behind it.

Thirty matched on their own.

Fifteen are less certain, so they wait for a person.

Step four: fix what’s unclear.

Only the questions the files can’t settle.

Is the workbook’s subtotal out of date?

Should the same person manage a project and also sign off its change orders?

Each question comes with a best guess filled in,

and one answer covers every record it affects.

Where the files have no answer at all, like a board approval date,

a person types it in.

Step five: load and verify.

A dry run shows exactly what will be written.

Nothing moves until a named approver at the district signs off.

This demo then loads into a simulated Kahua,

so you can see what its rules would reject.

Here, one change order.

Kahua’s rule sends large change orders through a board workflow,

and that rule isn’t visible ahead of time.

So Bridge explains it in plain words, and offers the fix that system expects.

Retry just that record, and it’s in.

Bridge remembers the fix for next time.

When Bridge loads into Kipso, it reads every record back,

and one click undoes the load.

Step six: the handover.

A load package in the destination’s own field names,

with a step-by-step import guide, and every decision and who made it.

After you import it with that system’s own tools,

export the records back, and Bridge checks every one against the load.

And a list shows what didn’t move, and why,

like a change order the old system never approved.

So what’s different?

Bridge follows each system’s own setup, not a generic template.

It shows its reasoning.

And it never loads anything without a person signing off.