Bisbe · the app that knows how your business works · being built now

“Why does everyone
still have to ask me?”

You answer it once. After that the app answers it — in your own words, with the page it came from and the date you last confirmed it.

Walk the whole app yourself — no sign‑in

The day it costs you

One question. Three people. One morning.

Not a crisis — a Tuesday. The same thing asked three times before lunch, and every answer came out of your head, because that is the only place it lives.

09:12
A rep, from the road
“Boutique wants samples before she orders. What do we send, and does she pay for them?”

You answered it. Typed out on your phone between two other things.
10:05
Someone new, at the counter
“Same question — I couldn't find it written down anywhere.”

You answered it again. The first answer was in a text message nobody else can see.
10:40
A customer, on her account
“Before I place this — can I see samples first?”

You answered it a third time. Slightly differently, because you were writing it from memory.

Three answers, one morning, nothing kept. Tomorrow the same question arrives again.

Why it needs an app

You already run four things. None of them keeps the answer.

This is not a gap you can close with more discipline. Every one of these was built to move a message along — and a moved message is exactly what an answer stops being the moment it is read.

The group chat
The answer was given here on Tuesday. It is now four hundred messages up, and nobody knows the words to search for.
The shared drive, with the procedure doc in it
Somebody wrote it down once. Nobody knows if it is still true — there is no date on it, and the last person who checked left.
The CRM nobody updates
It holds the accounts and the orders. It has nowhere to put an answer, so the reason behind every record lives in somebody's head. As for those records themselves, there are four ways in, below — each one saying where it stands.
The new hire shadowing someone
They learn how it is actually done. They learn it from one person, once, and what they picked up wrong shows up months later.

None of them keeps it, so you are the system. That is not a habit to fix — it is a missing place to put things.

How Bisbe helps

Answer it once. The app answers it after that.

The same morning, in one app. Nothing about how you answer changes — what changes is that the answer stops evaporating the moment it is read.

Somebody asks
A rep, a new hire, a customer on her own account. One place, whoever is asking.
The app answers, if it can
Out of what the business has already written down — with the page it came from and the date it was last confirmed. If nothing covers it, it says so rather than guessing.
You answer the ones it can't
Once, in your own words. Your wording is kept as written — tightening it here is how a procedure quietly changes, so nothing tightens it.
That answer becomes a page
Dated, versioned, and readable by everyone. The new hire learns from it. The customer is answered from it.

And the next person who asks gets it at step two — instantly, with the receipt, without reaching you. That is the loop: every question you answer is one you stop being asked.

What nobody else does

Four things that are not normal.

Plenty of software will hold your customers, or your chat, or your documents. These four are the reasons this is one app and not another one of those. Each row says where it stands today.

An answer with a receipt on itNever a guess Every answer names the page it came from and the date that page was last confirmed — and when nothing covers the question it says so and routes it to you, rather than inventing something plausible. An assistant that cannot say “this isn't written down” is the reason nobody trusts one. Running

The talking becomes the manualWritten by working Nine words typed in a room can be promoted into a written page — in the wording the person actually used. The manual is not a project somebody has to go and write; it accumulates out of the work, which is the only version of it that ever stays current. Rooms fold in next

Your customer watches their own claimThe honest wait The part nobody shows a customer is the wait — so they ring every Thursday to ask. Here they see it, on their own record, in the thread they were already in. No portal, no second login, no ticket number. Drawn, not built

Your own AI reads the same truthOne door, not a side one The Claude or ChatGPT you already pay for plugs into the manual through one standard connector — and every screen sits on a published web-service layer, so your own scripts attach the same way. Through the same door a person uses, never a side entrance. What that layer is, and what it is not. Running on the manual

The shape of it

One app, many workspaces.

A drawing of the app, not a screenshot — it is not one app yet, and each row of §What's in it says which parts are. Click through the rail — all seven, one invented business at one moment: Atlantica, a resort-wear wholesaler in Punta Cana, on Wednesday 12 August at 10:40, with claim #1042 at step 6 of 8. Each pane is the top of that screen, not the whole of it, and where a workspace has shipped its menu is read from the running app rather than drawn. The detail is one click away, in the walkthrough.

AtlanticaPunta Cana · Wed 12 Aug 10:40 Signed in as Maria Reyes, owner — a sample account in a drawing of the app.

Following · claim #1042 Marisol's Beachwear · 12 Wave Overshirts, side seam · step 6 of 8 Walk the full story

Ask anythingAtlantica · Maria's morning · Wed 12 Aug 10:40 AskHistory

Ask anything about how we do things…

Claim #1042 Sat 8 Aug 09:14

Marisol Vega · buyer, Marisol's Beachwear

“Twelve of the 24 Wave Overshirts came through with the side seam failing. Are we covered?”

Yes — faulty goods are covered for 90 days from delivery, and that run went out 11 days ago.

Returns and faulty goods · v4 · confirmed 12 June

Needs you · 3

A page is proposed — “when a replacement is on backorder”Needs you

Ana Ruiz asked: do we ship split cases on a first order?Needs you

The whole morning — 14 questions, every one with its page attached — is in the walkthrough.

See this screen in full

Concept render — in build

The story

Your customer watches their own claim.

A run of stock comes through faulty. Watch what Atlantica's buyer sees — an answer in seconds, a claim with no form, and a wait they can watch instead of ringing about.

The buyer · a boutique account
“Twelve of the 24 Wave Overshirts came through with the side seam failing. Are we covered?”

Asked in her own thread on Atlantica's account — where her orders and claims already live. No new login, no ticket form.
The app · instantly
“Yes — faulty goods are covered for 90 days from delivery, and yours went out 11 days ago.”

Returns and faulty goods · v4 · confirmed 12 June

Straight out of Atlantica's written manual, with the page they can tap and read themselves. Then: “Return the affected run and we replace like-for-like. File the claim?”
The buyer
“Yes, please.”

In the same thread
Claim #1042 filed · 12 × Wave Overshirt · side seam

No form. No portal. No second login. One tap, in the conversation they were already having.
Atlantica
“Returned run received Tuesday.”

Logged once, at the counter. The buyer's side of the claim updates itself.
Atlantica
“Inspected — stitching fault across the whole dye lot. Covered.”

The verdict, in plain words, the moment it is known.
Atlantica · the honest wait
“Replacement lot is on backorder at the mill — it ships the day it lands.”

Waiting · ETA 22 Aug

This is the part nobody ever shows a customer — so they ring every Thursday to ask. Here they just see it. A wait you can watch stops feeling like being ignored.
Atlantica
“Shipped — 12 replacements, new lot.”

Tracking · TR-4417-08

Same thread, start to finish. They never had to ask where it was.
And it closes the loop
The backorder line is written into Atlantica's manual.

The next buyer who asks gets it at step two — instantly, with receipts. The same question is never worked twice.

What of this runs today

Three of these eight beats run; the rest are sample states. Step one is a real record — the wholesale claim on the side seams is a thread on Atlantica's account, and it stands on the work board as a job waiting on Maria, projected from the thread rather than typed onto a board by hand. Step two is the written manual answering out of Maria's own words, with the page, its version and the date she last confirmed it. Step eight is the loop, and it is real machinery rather than a promise: an answer the owner gives is released into the manual as a page and the thread is marked learned, so the same question is answered at step two next time. The world carries one that has been all the way round — a rep asking where samples can go, now a page called Sample requests — though not this claim's own. All three you can walk right now.

Drawn rather than running: the middle of it — filing the claim in one tap, the returned run logged at the counter, the verdict, the backorder wait with its date, the tracking line. And the buyer's own side throughout: there is no buyer-facing claim thread and no watchable work item on the customer's side yet, which is the same piece §What's in it names as still to come on the work board. Nothing here pretends otherwise.

This is the same incident the seven workspaces above show from Atlantica's side: one company, one story. The band holds it frozen at step 6; this section runs the whole arc.

What's in it

One app. The capabilities you turn on.

The four differences are above; this is the whole inventory. Not five apps you buy and wire together — you switch them on as the business needs them, and they all sit on the same record. Each row says plainly what's running and what isn't.

The written manualKnowledge Answers in the owner's own words, with the page and the date it was last confirmed. Never a guess — anything uncovered goes to the owner to answer once. Running

Customers and ordersCustomers The day, ranked, with a reason under every stop. One typed line becomes drafted follow-ups, tasks and orders — every one held until somebody signs. Running

One list of what needs youQueue · Waiting on you Everything across Bisbe waiting on your word, longest-waiting first: the questions nobody has answered yet, the pages drafted for your manual, and the orders drafted on your behalf and held. Every row is a record that already exists, so there is no second to-do list to keep up to date. The support counter's own waiting conversations are not read into it yet — and whatever is not counted is named on the screen, with the reason, rather than shown as a zero. Running · Support not counted

Rooms and threadsComms Where the team talks, in the shape they already know — and any message can be promoted into the manual, so the talking becomes the written company. Runs separately · folding in

Work you can watchWork Every known job named, owned and visible on one board — so nothing that gets started quietly gets dropped. You add a job by asking for what you need: if the manual already covers it you get the answer and no job is made, and if it doesn't, it lands in Waiting with the question attached. Your own customer watching their job is the half still to come — deliberately not built, rather than half-drawn. Running · your side

Training from your manualTraining A new hire learns from what the business already wrote down — taught, not read once, and it follows the manual when the manual changes. It opened alongside the board: Atlantica's 20 written pages are 20 lessons, nothing invented, and a page nobody has re-confirmed lately still teaches and says its age out loud. Progress saving is in build — a read mark is kept on that device, so nobody else can see it and another browser starts fresh. Running · progress in build

The support counterHelp · five steps How you get help is part of the product, not an add-on beside it. It opened on 9 August: you ask in place, the written manual answers with the page, and anything it doesn't cover becomes a thread with a person. Your own customers knocking on your counter is the direction still to come. The five steps are just below. Open · one direction

What makes it one app is the spine underneath — one record, one login, one design language, one demo world. What the capabilities don't do yet is hand off to each other automatically. That's designed, not built, and it's the honest gap between “one product” as a decision and “one product” as software.

Support

One window, and it works both ways.

Your customers knock here — outside your business, asking in; your written manual answers them, and anything it doesn't cover reaches your team rather than being guessed at. And you, about Bisbe itself, get help here too, from us — answered out of our manual, and reaching our team when it isn't written down yet. No separate site, no portal. Either way you never leave the window you were already in. Who can ask us today is narrower than that sentence sounds, and the block at the foot of this section says how narrow.

The five steps below are that path walked from your side — you, asking us. Your customers' path through your own counter is the same five steps, with your manual and your team where ours are. One counter, whoever is standing at it.

You ask, right where you're working
No portal to find, no form, no support address to look up.
The answer comes back instantly, with receipts
Out of the written manual, with the page you can tap. If it isn't covered, you're told so — never guessed at. Most questions end here.
Not in the manual? It becomes a thread with our team
Same window. A conversation with the people who build this — not a ticket in a portal.
Needs real work? You get to watch it
Live status on the same board that runs our own build — not a private copy kept for customers.
Done? The answer is written into the manual
So the next person gets it at step two. The same question is never worked twice — support gets faster the longer you stay.

No ticket black hole. No “have you tried…” script. No waiting to be triaged by someone who just met your problem.

Where the counter stands today

Status, plainly: the counter is open — you can ask in place, the written manual answers with the page it came from, and anything it doesn't cover becomes a thread with a real person. Watching a request turn into work is the one step that isn't built yet, and that's what's being built, at the weight it will have. The counter lives inside Bisbe rather than on this page, so the way in today is the walkable read-only app, where the whole loop stands on practice records. Signing in to change it is coming soon, not open.

Who can ask us today: accounts on our own desk. A question to us from an account at another organisation would be a conversation with two organisations in it — so the app refuses it and says why, rather than guessing. The rule that keeps one organisation's records out of another's is in the database, so the fence itself is sound; opening this door across organisations is a decision nobody has made yet, and it stays shut until somebody makes it. Your own customers knocking on your counter is the same shape of decision, one door along.

Want to talk to us in the meantime? There's a form at the foot of this page, and a person reads everything that comes through it. You can also open this counter in the walkable app and read the real threads behind it — no sign-in. Asking us from inside the product, the way your own customers will ask you, is the counter above — you can read it today, and it opens to write once the sign-in work is finished.

Get your data in

You already have years of records. Here is how they arrive.

Nobody starts a business the day they buy software. Your accounts, your orders, your contacts and the reasons behind them are already somewhere — in a CRM, in a spreadsheet, in a drive, in somebody's head. There are four ways in, and most businesses use more than one.

Load them in bulk, and get a receiptFiles in, files out Your records travel as a folder of plain files — one per table, the real column names, the real empty values, and a note saying how many rows each file holds and a fingerprint of its contents. Every count was counted from the rows actually written, so it is a receipt rather than a claim. The same bundle loads back in: matched on the identifier each table is really keyed by, so loading it twice changes nothing the second time, and nothing is ever deleted. If a bundle disagrees with its own note about how many rows it holds, none of it is loaded and the reply names the file and the difference. Two things a file is never allowed to decide: which business the records belong to, and whether that business exists. See both controls in the walkable app. Running

Don't move them — keep your CRMThe Customers slot Bisbe is seven doors over one small, honest data shape, and the Customers door is a slot. Put your own system in it and everything else carries on exactly as it did: the manual still answers with receipts, the counter still opens, the training still builds from your own pages, the board still shows what is moving. The mapping is published door by door, and there is a worked walkthrough of a company doing this swap end to end — including the awkward parts: filling it the first time, keeping it in step, and proving it stayed right. Each service carries its checks in writing: ours that we run, and yours that you run. The connectors themselves open in stages, and the door documents say which stage each is at. This is not an all-or-nothing swap. The three ways to plug yours in — including the one where we write it. Specs published · connectors staged

Hand it to your own developerRead the specs today Everything an integrator needs in order to map your system onto ours is written, merged and readable right now: a document per door, the five shared layers every door is described against, the stored shape, the write commands, the connector tools, and a test path so all of it can be tried without touching a real business's records. Learn the five layers once and each new door is a two-minute read. What is not open is the live endpoints — that is the web-service layer below, and it opens after the specifications rather than before them. Specs published · endpoints staged

Start empty and let it fillThe manual writes itself The one nobody else offers, because it is not an import at all: you answer questions, and the app keeps the answers as written pages. A month of the loop above and the manual exists — in your words, dated, and covering exactly what people actually ask. Most businesses do this alongside one of the three above, because the records import and the knowledge does not: nothing you own today holds the reasons. You can also press the download on the demo first and read what comes out, so you see the shape of the thing before committing anything to it. Running

Web services

Your own AI and your own scripts, on the same truth.

The use case: you have an assistant you already pay for, a couple of scripts that run your Monday, and probably a system nobody is going to replace. All of them need the same answer the screens give — and none of them should be getting it by scraping a page or keeping a second copy that goes stale. Every screen in Bisbe sits on a service layer, and that layer is the door.

The AI you already pay forOne standard connector Your own Claude or ChatGPT plugs into the written manual through one standard connector — nothing new to learn, no copying between windows — and it answers with the same receipts the app does: the page, the version, and the date it was last confirmed. It reaches exactly what a person reaches, through the same door a person uses, never a side entrance. Running on the manual

The specifications, publishedWritten for someone outside Written for a developer at another company who cannot see our code and should not have to. A document per door, the five shared layers every door is described against — the data shape, how it is read, how it is written, how it is fenced to one business, and how records move in and out in bulk — plus the stored shape, the write commands and the connector tools. Learn the five once and each new door is a two-minute read. Published

A contract test per serviceThe spec is not a promise Each door's contract carries its own test, in the codebase, run on every change — so the published description and the running software cannot drift apart quietly, which is the ordinary way an integration guide becomes fiction. There is a test path and a bulk-upload path written down as well, so your side can be tried end to end without touching a real business's records. Running in the build

Endpoints you can call yourselfThe part that is not open There is no public API you can call yet. Not one. The specifications are written, the seams are named door by door, the tests are defined — and the endpoints open in stages after that, deliberately, so what opens is what was designed rather than what was convenient. Anything on this page that read like “connect it today” would be the one claim here that is not true, which is why none of it does. Not exposed yet

Plug in what you run

The system you already run is not worth replacing.

The use case: you bought or built a CRM years ago and a decade of custom routines has grown into it. Your people live in it. Nobody is moving off it and nobody should be asked to. What you actually want is both at once — your own system carrying on exactly as it does today, and every Customers feature in Bisbe working off the same records. There are three ways to get there, and one of them is us doing the work. The fourth row below is what it looks like once one of them lands.

Bring the records, keep the systemThe lightest way in The lightest way in, and the one that works today: your accounts, contacts, orders and drafts travel as a bundle, and the same bundle loads back in — matched on the identifier each table is really keyed by, so loading it twice changes nothing the second time, and nothing is ever deleted. Every count is counted from the rows actually written, so it is a receipt rather than a claim. Your own system carries on untouched throughout, because nothing here reaches into it. The four ways your records arrive. Running

Hand it to your own developerEverything is written down If you have somebody who already maintains the custom routines, they do not need us in the room. A document per door, the five shared layers every door is described against, the stored shape, the write commands, the connector tools — and a worked walkthrough of a company doing exactly this swap, including the awkward parts: filling it the first time, keeping it in step, and proving it stayed right. What is not open is the live endpoints. What that layer is, and what it is not. Published · endpoints staged

We write the adapterOur work, not yours If you run a system we should be talking to, our team writes the piece that talks to it. That is an offer we are making deliberately, to any system’s makers who want to be on this list — and it is not a promise from nowhere: we have written two of them already, for two Cin7 products, mapped onto the maker’s own documented pages and cited line by line. What is not written yet is the part that makes the calls, so neither of those two can be connected today and this page will not imply otherwise. Cin7 or any system you run — the two doors, and how you start, are below. Written twice · not connectable yet

Both, at the same timeThe answer to the actual question The end state row 3 is built toward, said plainly because it is what people are really asking: your own system stays the one your people open every morning — its custom routines, its modules, its reports, standalone and unchanged — and Bisbe’s Customers door reads and writes the same records through the adapter, so the manual, the answering, the training and the board all work off them too. This one is a direction, not a door you can walk through. It needs the calling piece from row 3, and the version of it for customer records is written as a contract and not built. It is drawn here at full weight because it is the point of the whole section, and marked so nobody plans a quarter around it. In build · not available

Cin7, or the system you actually run

Two doors, and you pick. One of them has been walked already; the other is the one most people will need, because most businesses run something nobody else has.

Cin7

The one that has been through this. Two of its products are written down in full: every question we would ask placed on their own documented pages and cited line by line, what you would enter and where you find it, the cheapest question to ask when testing a connection, and a check that notices if a key starts opening a different account. Adding one is a piece of code and a line in a list — no screens change and nothing else moves. What is not written is the part that makes the calls, so it is not something you can switch on today; what exists is the whole of the mapping, in the open, where you or your developer can read it before deciding anything.

Written twice · not connectable yet

Any other system — including one you built

Whatever you run: a product nobody else has heard of, a decade of your own custom modules, or something in between. You send us its specs and we write the piece that talks to it — and then we keep it working as their side changes. That is the offer, it is open to any system’s makers who want to be on this list, and the three steps below are the whole of the process.

We write it on request

Coming soon Standard interfaces for the systems most businesses already run — written once by us and available to everybody, rather than one request at a time. None of them is finished, so none is named here and no date is put on it: when one lands it will appear on this page with its own state on it, the way every other row here does.

The process, and it is a support request. One — you send what your system publishes: the maker’s own reference pages, or whatever your developer wrote for the parts you built yourself, plus what you need it to do. Two — we come back with what it would take: the questions we would ask your system, what we would need from you, and anything it turns out we cannot get at. Three — we write the piece and we keep it working. Cin7 is the one that has been through steps one and two, and its writing is what the box above is pointing at.

Send us your system’s specs

What that form does today: it checks what you typed and then either takes the message or tells you plainly that it could not send it. It never says thank you into a void. And no, you cannot do this part yourself yet — there is no screen where you map your own system onto ours, because mapping is work we do in code and publish so anyone can check it. If that ever changes this page will say so. Until then, the request above is the way in.

What is true today

Row 1 runs. Records out and the same records back, with the counts that make it a receipt — press it on the demo and read what comes out. Row 2 is published and readable right now, and it is the same set of documents our own people build from; what is staged is the live endpoints, which open after the specifications rather than before them. Row 3 is an offer plus a proven pattern — written twice, both times against a real maker’s published documentation, and neither one connectable until the calling piece is built. Row 4 is where those two meet, and it is not there yet. Which system gets written next is decided by who asks, which is what the three steps above are for.

How much stays yours

Your records, in a database you own.

Your CRM can stay where it is and your scripts can read the same truth — both of those are above, and both are real today. This one is the deeper version of the same question: whether the rows themselves ever have to sit in our database at all. It is the direction the product is built to, and it is not a door you can walk through yet.

Your own databaseThe direction we build to The product is built so a business's content can live in tables that business owns, and the shape of that holds in the source today: the control side of Bisbe — who you are, what you have switched on, how much you have used — never carries your content, and the code that reads your records takes the connection as an argument rather than owning one. What we would still see is short, and this is the whole list: sign-ins, what is switched on, usage counts, error reports. Never your records. And one limit that is permanent rather than temporary: if the database is yours, anyone you give direct access to it is invisible to us — we can only ever show you what happened through Bisbe. In build · not available

What is open today

The documentation is. It is written for a developer at another company who cannot see our code and should not have to — a door document each, the five shared layers, a worked bring-your-own-CRM walkthrough, and a straight answer on backfill and staying consistent. Records in and out is. The bundle comes out and the same bundle loads back, with the counts that make it a receipt — press it on the demo and read what comes out. The public endpoints are not. There is no API you can call yet, and this page will not pretend otherwise: exposing them deliberately comes after the specs, so what opens is what was designed rather than what was convenient. Bringing your own database is a direction, not a door you can walk through — it is drawn here at full weight because it is what we are building to, and marked so that nobody plans a quarter around it.

The offerings

Five shapes. You pick how much stays yours.

The difference between these is not how many features you get — the first four are how much of the plumbing you keep, and the fifth is whose product it is. The whole product is in every one of them.

Bisbe, hostedWe run all of it The whole suite on our infrastructure: the written manual, the rooms, customers and orders, the work board, training built from your own pages, and the support counter. One record, one login, capabilities switched on as the business needs them. Nothing to install and nothing to keep running. Demo open · go-live ahead

Bisbe with your own CRMKeep the system you have Everything above, with your existing customer system in the Customers slot instead of ours. The manual, the counter, the training and the board all keep working against it, and the mapping is documented door by door. Specs published · connectors staged

Bisbe with your own databaseYour records stay yours Everything above, with your business's content living in a database you own and administer. We would hold identity, what is switched on, usage counts and error reports — and none of your records. In build · not available

One piece on its ownStart where it hurts Some businesses only want the written manual that answers with receipts, or only the counter their customers knock on. A single capability can stand by itself, and the others switch on later against the same record — which is what "one app with capabilities" actually buys you. Shape defined · not packaged yet

Full white labelYour name on it, not ours Some businesses need the app their staff and customers use to be theirs. It would carry your name, logo and colours with nothing of ours on the screens inside it; sit at your own web address, once you point it at us; and be run by your own admin, who adds and removes people and chooses what each can open. How it works, step by step → In build · not available

Why there are no prices

None are set, and that is not coyness. When they are, they will be on this page in plain numbers, rather than behind a form or a call — the same rule as everything else here. What you can do meanwhile is see the whole thing, free and without telling us who you are, and then decide whether it is worth a conversation.

Seeing it for yourself

No sign-in, no form, and no sales call.

Nobody should have to book a call — or hand over an email — to find out what this is. You'll meet Bisbe by using a whole business already running in it: walk the whole app yourself, or take the guided tour where one client's claim moves through every capability. Both open on one click and ask you for nothing. Then, at go-live, you sign yourself up for your own and connect your own apps, with nobody from here standing behind it. No sales call, no integration help, ever.

Walk the whole app yourself — no sign‑in See the guided tour Play in the live demo world Coming soon

Can you try it today

Yes — two ways, and neither one asks you for anything. Walking the app opens every one of the seven doors, read-only: the whole thing laid out as it really is, seeded with an invented business, with nothing behind it to write to. The guided tour takes the same world and walks you through one client's claim as it crosses all seven. Signing in and changing it is not open — the world you can write into is marked coming soon above, and until it opens there is no account to make and no password to pick. What you cannot do yet is run your own business in it — that is what a signed-up customer gets at go-live, and it is not open either. The manual, the customer record and the support counter are running on real data; the rooms are folding in; the work board and the training are open too — with your customer's own view of a job, and progress that saves off the device, the two pieces still in build. Hosted, one subscription, capabilities you turn on as you need them — and no prices are set, so none are shown.

Talk to us

Ask us anything. A person reads it.

There is no sales team to get past and no call to book. If you want to know whether this would work for your business, whether your own system can go in the Customers slot, or when something on this page opens — ask, and you will get a straight answer from someone who built it.

About the business in these screens

Atlantica is invented. The resort-wear wholesaler in Punta Cana, its people, its accounts and its procedure pages are our own demo business, built so this page and the walkable app can show real screens over real records without ever showing you somebody else's. No real business, brand, person or product appears anywhere on this page.

The faulty-goods claim is a genericised composite of a problem a real beta user really had, drawn as sample states and captioned as such wherever it appears. The names, the quantities and the dates in it are ours.

No prices appear, because none are set. Not a range, not a “from”, not a tier name that implies a ladder. When there are prices they will be on this page in plain numbers.

Every claim here is written to be true at the moment it renders, and anything not built says so in the same breath, at the same size as the claim. That is a rule this page is checked against rather than one it promises to keep.

“Why does everyonestill have to ask me?”