Build the app.
Keep control of the data.
AI can build a working app in an afternoon. It can't decide who owns a process, which record is the master copy or who can approve a payment. Make those decisions first, before the screens make it all look finished.
- Business rules first
- Separate apps and data
- Operate what you build
Start with the job, not the screen
AI makes it easy to jump straight to the screens. First describe one complete piece of work from start to finish: who starts it, what information they need, what decision gets made, what data changes and who fixes it when something goes wrong.
Try what you already own
Check whether your current system can do the job with different settings. A small gap doesn't justify building and owning a whole new product. Compare setup, connecting it to your other systems, licences, support and the cost of leaving later.
Build where it gives you an edge
Building makes sense when an important process is poorly served by existing tools, the scope is limited and you can maintain it yourself. Simple tools with expensive SaaS options are often the best targets. The task is straightforward, but the price rises with users and features. "AI can build it quickly" tells you the cost of the first version, not the whole business case.
Our example: the CRM features we needed all sat in the higher plans making it cost prohibitive, so we built our own.
Name who owns it and what happens if it fails
Decide who approves the rules, who supports the app and how work carries on if it goes down. If you can't answer those yet, build a throwaway prototype with made-up data until you can.
Decide what is out of scope
For a small marketing CRM, contact history and follow-up might be in. Customer portal might not be. Write the limits down. Without them, a string of small requests grows into a much bigger system.
Treat anything customers or partners use as a separate decision. A customer portal puts your app on the public internet, which raises the security risk. It can also raise licence costs, because external users often need their own licences. It may still be worth building, but assess it on its own before it is added to the scope.
Write the decision down before you build
The problem: we had no CRM. Our pipeline lived in emails, with no connected view from campaign to enquiry to managed lead, so we couldn't tell what was working.
The goal: follow every lead from campaign to outcome, see what works and what doesn't, and keep customer data secure and their privacy respected.
The options to weigh:
- Change the settings in the CRM you already have
- Extend the Microsoft 365 tools we already pay for
- Buy a specialist product
- Build a small app
Then record the decision:
- What you chose, and what you rejected and why
- Who owns the data
- Who can see it and who can change it
- Who supports it
- How you'll know it worked
- What would make you revisit the decision
Separate the parts, then challenge every door
For our marketing CRM, we built on Microsoft infrastructure and gave each part one job: what people use, where the data lives and what runs in the background. This is a security decision as much as a tidy one. The data sits in one place with one set of access rules, and everything else has to go through them.
The app: the user experience
Most people think of the app as the experience: the screens, menus and buttons. It is also your first layer of security.
Show people only what their role allows: Good security design improves the experience as well. When each role sees only what it needs, there is less clutter, fewer wrong turns and a more streamlined process. Hiding options isn't protection on its own, because a screen can be bypassed, so the layers behind it must check again. The app should never hold a second copy of the data.
The business rules: what is allowed
This layer decides what each role can do and checks every request, whether it comes from the app, an automation or an AI assistant. The rules live here once, so nothing is repeated and nothing can skip them.
Automation uses its own controlled sign-in with access only to what the process needs. One all-powerful automation account is the most common back door.
The data: the master copy
The last line of defence. It enforces the same roles, so a request that slips past the layers above still can't reach what it shouldn't. Give every record a unique ID, and decide how corrections and history are kept.
For sensitive data, keep an audit record. Log who viewed, changed or deleted a record, when, and through which route, including automations and AI assistants. Nobody should be able to edit or delete the log, including the people it records.
Weak access design is the expensive mistake
Adding access control later means reworking every screen, automation and report that assumed everyone could do everything. Each one is a place where a back door can survive.
It is also a legal risk. Australian law requires reasonable steps to protect personal information, including technical and organisational measures, and serious breaches can attract very large penalties. The first penalty, $5.8 million, was ordered by the Federal Court against Australian Clinical Labs after a breach affecting more than 223,000 people. It included $4.2 million for failing to take reasonable steps to protect that information. The court pointed to steps such as access management, logging and multi-factor authentication as what a reasonable organisation has in place.
Build access in from the start, and you can show you took them.
Make the security model core, even for version one
Give every screen, part of a screen and action an access level for each role. No access, read and edit are the minimum. Add create, delete, approve and export where the risk is higher. Then decide which records each role can see, and which sensitive details are hidden.
Attach access to roles, not people. If version one has one type of user, give everyone the same role.
Have AI build the control: Ask it to keep a map of every screen, section and action, so any new function defaults to no access. Ask for an admin screen where roles are created and linked to Microsoft or Google groups. Restrict it to administrators and audit every change, with a simple view of who accessed sensitive records.
How you design the data decides how much repair work follows
A polished screen can hide a messy data design. Decide what makes each record unique and what rules govern changes to it, before you build any dashboards. Don't assume AI will give you a clean structure. It often over engineers and does not clean up after changes.
Describe the business, not the database
Tell the AI what you keep track of, how you tell one item from another and what happens to each from start to finish. Use plain words: "An enquiry arrives, gets an owner, is followed up and is closed with an outcome." The AI turns that into a structure.
Make the AI explain its design
Ask for the structure as a simple table or diagram in business terms, with no code. If you can't follow it, ask for a clearer explanation. Then ask the AI to label each part as a foundation or an extra, and to say what real need each extra serves. Never trim the foundations to make things simpler: unique IDs, shared master lists, access control, data checks, audit and change history. Question the extras.
Test it with awkward cases
Add the same contact twice. Rename a company. Open one record in two windows and change both. Delete something and see what's left behind. Faults found now cost minutes. After launch they cost trust.
Check what's left behind
AI rarely tidies up. After each change, old fields, unused lists and second copies of the same values tend to stay. Ask what the change made redundant, and have it removed only after a dependency check.
Know where AI needs watching
AI builds for the day everything works. It rarely thinks about the day something doesn't: a connection drops, someone clicks twice, an email address is wrong. You can't list every way an app can fail, but you can learn the habits to watch for. These are four common ones.
AI often assumes nothing goes wrong
It builds the smooth path and leaves the rest to chance. Then a slow connection means a half-finished job is lost.
AI often hides errors to look tidy
It will quietly swallow a failure so the screen stays clean. A failure nobody sees is worse than one that makes a noise, because nobody fixes it.
AI often creates duplicates
Submit the same form twice and you can get two records. The copies are hard to spot in testing, and expensive once they're in your data. AI doesn't automatically check for duplicates caused by double clicks, slow connections or a page refresh.
AI often weakens a check to fix an error
Told to make an error go away, it may relax a rule instead of solving the cause. The error disappears and so does the protection.
Ask the question, not just the checklist
Your app will fail in ways these examples don't cover. What carries across is one question: "What happens when this goes wrong?" Ask it of every feature, and make the AI answer in plain English.
Then try to break it yourself, on a staging copy. Submit the same form twice, enter a bad email address, or cut the connection halfway through. If you can't tell what happened, or nobody would be told, fix that first.
Ask the AI to design for failure before it builds any automation. Copy the failure guardrails from the Master Prompts page.
AI built it. Decide where AI should run it.
Having AI build your app is a one-off cost. Having AI work inside it costs money every time it runs, and it can give a different answer each time. That is a design decision, so make it early. Decide where AI helps, where plain rules do the job, and how AI connects to everything else.
Use plain rules when there's a clear right answer
Checking a field is filled in, sending an enquiry to the right person, adding up numbers and deciding who can see what. Rules that give the same answer every time, cost almost nothing and are easy to test. AI can still write them. It shouldn't run them.
Use AI where judgement helps
Understanding what someone is asking for, summarising notes, sorting messy text, finding the right guidance or drafting a reply. Decide what happens when the AI isn't sure. Have a person confirm anything that can't be undone, such as sending to a customer or changing a record.
Let AI propose, and let the rules decide
Design AI in from the start and it can interpret a request and then do the work: find a record, update a document, start a task. But it goes through the same business rules as everyone else, as the signed-in person, with that person's access and nothing more.
Our example: How we use Kira
Kira, our AI assistant, can use our instructions to edit our KJM Flow documents or helps us find our way around the app. We designed it in from the start, so it works through the same business rules and roles as any member of staff. It understands what we ask. The rules decide whether it's allowed.
A simple test for every step
Imagine AI reads every enquiry just to check an email address is filled in. You pay for each check, the bigger the data set the more you pay. And it might occasionally get it wrong. A simple rule does the same job for free and never gets it wrong.
For each step in your app, ask: does this need judgement, or is there a clear right answer? Ask the AI to answer that for you before it builds.
A demo isn't a test
AI will tell you it works, and a demo will look fine. But you still need to test it before real people or real data are involved. Plan it, and do it on a staging copy.
Ask the AI to help you write the test plan.
Once testing is complete have AI document the build. Ask for one document that covers what the app does, how it is put together, where the source code is stored, which version is current and who owns each part. Put your master prompt at the end of that document. Attach the document and the source code to every new AI session, and the AI starts with the whole build and the rules for changing it. Update it with every version.
Where to go next
Each guide covers a different part of building with AI safely. Pick the one that matches what you're working on.