all work

call cockpit

a deal sourcing cockpit, with everything one click away.

our client buys companies, and he does it quietly. his whole pipeline lived in google sheets, including phone numbers and notes from calls that exist nowhere else. we built call cockpit, one screen where he and his assistants work through the calls while every record behind it stays in sync.

industry
m&a deal sourcing
country
germany
app type
web app
built with
bubble
our part
scoped it, prototyped it and built it from scratch
handed over
october 2026
the call queue. today's calls on the left, the whole company on the right

the app

what call cockpit does.

our client finds companies to buy across germany and the rest of europe, and he keeps a low profile while he does it. in his words: "in this business, it is always best if one is not immediately categorized in the m&a sector. that is why there is no website."

everything ran on google sheets. the formulas were long and broke easily. and the sheet held his most valuable asset, phone numbers, figures and notes he had gathered call by call. he couldn't share it with an assistant without handing over all of it.

he wanted a cockpit, like a pilot's. everything he needs on one screen, one click away. his assistants make the calls, and the data stays his.

every target company in one row, with its figures and decision maker
  1. bring the data in

    companies and people come in from a spreadsheet. duplicates are caught on the way in.

  2. build a campaign

    pick the companies to approach, give each campaign its own pitch, and set who comes first.

  3. work the queue

    open a company and see its figures, owners, decision maker and every past call on the same screen.

  4. log it in one click

    busy, voicemail, call back. add a note, set the next time, and the company comes back to the queue when it's due.

the screens on this page are from the clickable prototype we built first, which the final app copies screen for screen. every company, person and number in them is made up.

our part

what we did.

our client knew exactly how his work runs. our job was to make the software fit that, not the other way round.

one screen for the whole call

12 panels on the cockpit: the queue, company figures, owners and managers, decision maker, status, quick times, notes, call events, history and the pitch. nobody clicks through tabs in the middle of a call.

the call queue, with call events and quick times one click away

change it once, it's right everywhere

change a decision maker or a status on the cockpit, and the company, the person and the history all update behind it. this was the hardest part to build, and the part nobody sees.

bubble
every company in every campaign, with its stage and priority

assistants do the calls, the owner keeps the data

each person gets a role. assistants see what they need to make the call and nothing more. the owner sees and controls everything.

shareholders and managers, and who actually decides

numbers the way the source has them

around 90% of the company figures he works with are never published. the app says so, instead of showing a zero, because a zero would be wrong.

his data, in and out

the data was too tangled for any ready made import tool. we built the upload and the download from scratch, keeping every link between companies, people and history, so his data can go anywhere later.

csv
bulk upload for companies and people, duplicates skipped

how we did it

step by step.

a board, a prototype, then the real thing.

  1. scoped on a board

    we mapped every screen and rule with the client before building anything.

    miro
  2. a clickable prototype first

    we built the whole product as a prototype he could click through, so changing his mind cost nothing.

    lovable
  3. built from scratch, shown every week

    then we built the real app. every delivery came with a short video showing what changed.

    bubbleloom
  4. tested on real work

    the client ran live campaigns on it before handover. every issue went into one shared list, and we worked through it item by item.

    slack
  5. handed over properly

    we moved the app into his own account, recorded a walkthrough for anyone who works on it next, and stayed on for 30 days of free support.

the tricky part

the prototype looked right to everyone. then the client started using the real thing with his real data, and the real list began. his figures took a week to check properly each round, and screens that looked finished needed rework. by august the list was long, and the client told us plainly he wasn't sure it would ever be usable. ehsan's answer was one line: "that is the problem i want to solve. everything else can wait." so we stopped adding. a bigger change was parked for a later phase, every open problem came first, and we didn't bill a single extra hour. by october he was running live campaigns on it, and we handed it over.

we both underestimated how complex this was, and i take responsibility for that, because i'm the more experienced one. but we didn't rush it. we kept the client in the loop every week, and we finished it.

ehsan, co-founder

where it is now

one screen, a whole pipeline behind it.

12panels on one cockpit screen
14screens in the app
25background processes keeping every record in sync
30 daysof free support after handover

built with

what's inside.

  • bubblethe whole app, its data, the roles, and the upload and download
  • lovablelovablethe clickable prototype the client tested before we built
  • mirowhere we scoped every screen and rule
  • looma short video with every delivery
  • slackslackevery request and decision in one channel

next project.

semulator

tell us what you've built.

send a link or a few screenshots. honest reply within 3 hours, no sales pitch.