APPOSThe app platform for everyone
Let everyone
ship to
production.
Whoever sees a problem, in sales, customer success, marketing or legal, should be able to build the solution and put it into production.
Teams bring the ideas and their agents.
Engineering provides the platform.
The app-store model, inside your company.
from everywhereMarketingSalesCustomer successCROs & revenue teamsLegalOperations
01The bottleneck has moved
AppOS makes
shipping safe.
AI makes building software accessible across the company.
If every useful app needs engineers to review the implementation, bring it into their repository and maintain it, engineering becomes the bottleneck.
People will find another way, and a tool goes live on someone’s hosting account. When its creator leaves, nobody knows who owns it or what data it holds.
Letting everyone in the company ship takes shift left to the extreme. Development moves to the people who need the app, and engineering makes that possible by building the platform.
02Choose the operating model
Three ways to get
an idea into production.
Everyone can write more software now. Where do ownership, permissions and responsibility go when everyone starts shipping?
| Criterion | AppOSTEAMS SHIP. ENGINEERING ENABLES. | Engineering reviews the codeREVIEW. INTEGRATE. RELEASE. | Teams ship on their ownVERCEL / FLY.IO |
|---|---|---|---|
| Shipping | Teams deploy within the shared platform’s boundaries. | Engineering reviews, integrates and releases each app. | Teams deploy through their own accounts and projects. |
| Engineering owns | The platform, capabilities, policies and production controls. | Each adopted app, its integration and ongoing maintenance. | Whatever oversight the company separately establishes. |
| Implementation | Teams choose their language and internal architecture within the platform contract. | Code must fit the engineering team’s repository and conventions. | Teams choose their own stack and deployment setup. |
| Permissions | The platform checks the app’s grants and the person’s policy on every call. | Engineering implements and reviews access controls in each app. | Each team must arrange appropriate access to company data and services. |
| Visibility | Shared inventory of apps, owners, groups, permissions and versions. | Apps enter engineering’s existing inventory and processes. | Company-wide inventory and ownership must be organised across deployments. |
| When something breaks | Shared limits, logs, rollback and controls to stop an app. | Engineering diagnoses and fixes the adopted app. | The team operates its app using its hosting provider’s tools. |
| As more people build | More apps use the same platform and its shared controls. | More code enters engineering’s review and maintenance queue. | More independent deployments need company oversight. |
This compares organisational approaches. Vercel and Fly.io provide hosting and operational tools; company-wide access policy, ownership and lifecycle still need an operating model.
03Your phone shows the model
Apple didn’t build
most of the apps
on your phone.
The App Store opened the door to other people’s ideas, with distribution, permissions, review and a runtime boundary.
Your company has the same opportunity. The best idea for a sales tool may come from sales, and the best legal workflow from legal. Give those people a platform to build on.
Explore the AppOS architecture slides ↗An app of its own
Each app deploys on its own and has a named owner, versions and a lifecycle.
Declared permissions
Agree what an app may do. The platform enforces that boundary.
Exercise the app
Run the app instead of reading it. appfuzz is one way to automate that.
Enforced limits
Fresh isolation per request, with hard resource budgets.
04The sandbox shrinks the review
What the sandbox blocks,
nobody has to review.
Reviewing an app written by marketing usually means reading every line for what it might do: write to ORDERS, flood a server, delete files. AppOS runs the app as WebAssembly in a shell, where it can call only what it is granted. If it can’t write ORDERS, nobody has to check that it doesn’t. The review shrinks to what is granted, and appfuzz is one way to test that.
RADICAL CHANGERadical results.
More AI is not enough.
Change who ships.
Handing everyone AI and hoping the old process runs ten times faster won’t work. Letting marketing, sales and customer success ship to production is one radical change. AppOS is one way to make it safe.
05Engineering enables everyone
Engineering owns
the platform.
Teams should be free to solve their own problems. Engineering decides how apps may interact with the company.
Supported · appos build compiles it
- Rust
cargo · wasm32-wasip2 - TypeScript
scriptc, AOT - Zig
wasm32-freestanding - Java
Maven · TeaVM
Not supported · bring your own toolchain
- Go
TinyGo · wasip2 - C / C++
wasi-sdk · wit-bindgen - MoonBit
wit-bindgen moonbit - Odin
freestanding_wasm32 - Elixir
Orb · wasm-tools - Yours
wasm-tools component new
Not tested by us. Loads if its imports ⊆ appos:framework ∪ wasi:{io, clocks, random, cli}.
// app.wasm: a WASI 0.2 component package appos:framework@0.1.0; world app { import registry; // routes, init only import page; // the response import log; import kv; // needs a grant export handler; // init(), start(req) }
# app.toml: the manifest [app] id = "webinars" group = "Marketing" [capabilities] grant = ["kv-read", "kv-write"]
THE TEAMSPeople + their agents
They own the idea and the app.
The workflow, the content, the design and whether it solves the problem.
- Build and iterate in their own repository
- Choose a supported language and internal design
- Ship an app against the platform contract
ENGINEERINGThe shared platform
You own the production boundary.
The capabilities, data access, sign-in and controls that every app uses.
- Define which capabilities the platform offers
- Decide who may use each app
- Keep integrity rules in those capabilities
- Observe, limit, roll back or stop an app
Every request runs in
a fresh WebAssembly sandbox.
The app reaches company data only through the capabilities the platform provides. The app’s grants say what it may do; the company’s policy says who may make it do that. A call needs both.
Time, memory, instructions and I/O have hard budgets. A failed request discards its pending writes.
+ user policyBOTH MUST ALLOW
The app may read, and so may this person. The platform returns the app’s data.
AI code needs to pass more checks.
06Hardening
No code review.
Fuzz instead.
Nobody can read every app everyone ships. So don’t read them. Run them.
Hardening means checking an app before it goes live and fixing what the check finds. Before you deploy, appfuzz runs your app thousands of times and finds the crash, the leak and the slow page. It is one way to automate that check.
07Ideas become useful apps
Apps built by the people
who know the work.
Four working examples, each built from a team’s request, in different languages on the same AppOS shell.




Screenshots of the real example apps running locally. Kitewell is fictional. Explore all four apps and their original requests ↗
A contract intake tool.
Help colleagues submit the right information before a legal review.
A tool to test a new offer.
Turn a revenue experiment into something customers can try.
A better everyday workflow.
Replace a spreadsheet ritual with a tool that fits the work.
TRY ITOn your own machine.
Clone it. Run an app.
Make it your team’s.
AppOS is open source. Build it, start the shell and ship a working example app. Then turn it into something your team needs.
08Prevent shadow apps
Everyone can ship.
You still know
what runs.
Give teams an approved path to production and a shared home for their apps. Their initiative becomes something the company can see, operate and take responsibility for.
- A visible owner.Every deployed app names an owner and a group.
- A record of what happened.See versions, grants, usage, failures and platform events.
- A lifecycle beyond its creator.When someone leaves, find the app, arrange a handover or stop it.

The real AppOS admin console, with fictional example apps and temporary demo data.
Keep immutable app versions and make an earlier one live.
Automatic rollback when the live version repeatedly fails.
Adjust per-request time, memory and instruction limits.
Stop an app, freeze deploys or stop all apps.
Which apps does a bad
dependency affect?
With more teams shipping, more apps use libraries nobody in engineering picked. Gardening means checking the live apps regularly, because a library can turn unsafe long after the deploy. Every Rust app carries the list of crates compiled into it, and appos audit checks the live apps against the advisories published on osv.dev. It names each app that uses a vulnerable crate, its owner and the version with the fix.
TypeScript, Java and Zig apps carry no list yet, so the audit reports them as not checked.
From a dependency to the person who owns it.
advisory→Affected
app versions→Named
owners
APPOS AUDIT / OSV.DEV ADVISORIES + LIVE APP VERSIONS
Until its owner ships the fix, a vulnerable crate can do only what the app’s sandbox and grants allow.
A FEW FAIR QUESTIONSThe boundaries matter
Questions CTOs ask
about AppOS.
Is this just for marketing?
No. Marketing is the provocative example. Sales, customer success, revenue leaders, legal and operations all see problems worth solving. AppOS provides a common place for their apps to run.
Does engineering still review anything?
Yes. Engineering defines the platform contract and capabilities, sets policy and operates the platform. Hardening exercises the compiled app before it ships, against what the team agreed it needs to do. appfuzz is one way to automate that check; deploys don’t run it yet. Gardening keeps checking the live apps after that, such as their dependencies against new advisories.
Who may use an app?
Your policy decides, per app: a person, a group or everyone. People sign in with your company login.
Do we have to accept everyone’s source code into our repository?
Apps are deployed as their own bundles. Your platform contract and permitted capabilities define the boundary. Each app can keep its own source repository, language and internal design.
What if a team needs a new API?
Engineering provides the new capability and its integrity rules. Apps cannot make arbitrary network calls. The platform team continues to build the shared foundations everyone benefits from.
Does a sandbox make every app safe?
It confines execution and enforces capabilities and budgets. Teams still own business correctness, content and design. An app can misuse a capability it has been granted, so the scope of that capability matters.
Does AppOS find vulnerable dependencies today?
For Rust apps, yes, as part of gardening. appos audit finds crates with a published advisory or CVE, such as a version nobody updated. It cannot find an attack nobody has reported yet; the sandbox and hardening are there for that.
YOUR FIRST APPStart small. Make room for more.
Start with one idea.
Give it a way to ship.
Pick something a team wants to build. Agree what it may do. Put it on a platform the company can trust and operate.