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.

Open source · WebAssembly apps · Sign-in and production controls built in
Your company / one platformEveryone builds
Pricing calculatorMarketing
Discount approvalsSales
Customer status pageCustomer success
Webinar registrationMarketing
Different teams. Their own apps.
AppOSENGINEERING OWNS THE PLATFORM
PermissionsSandboxDataProduction controls

The app-store model, inside your company.

Ideas come
from everywhere
MarketingSalesCustomer 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.

YOUR TEAMAPPOS · THE PLATFORMMarketinghas the ideadescribes itAI agentany agentwritesWeb apptheir languagebuildsapp.wasmWebAssemblydeployAutomatic reviewruns the app instead of reading itappfuzzone way to automate itAppthe team’s appSandboxonly what is grantedpassesUseranyone using itusesPlatformengineeringsets the rules
YOUR TEAMMarketinghas the ideadescribes itAI agentany agentwritesWeb apptheir languagebuildsapp.wasmWebAssemblydeployAPPOS · THE PLATFORMAutomatic reviewruns the app instead of reading itappfuzzone way to automate itpassessets the rulesPlatformengineeringAppthe team’s appSandboxonly what is grantedusesUseranyone using it
How marketing ships with AppOS: the team and its agent build the app, an automatic review checks it, a sandbox runs it. appfuzz is one way to automate the review; today you run it before you deploy.

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?

Three organisational models for getting everyone’s apps into production, with criteria in the left-hand column
CriterionAppOSTEAMS SHIP. ENGINEERING ENABLES.Engineering reviews the codeREVIEW. INTEGRATE. RELEASE.Teams ship on their ownVERCEL / FLY.IO
ShippingTeams deploy within the shared platform’s boundaries.Engineering reviews, integrates and releases each app.Teams deploy through their own accounts and projects.
Engineering ownsThe platform, capabilities, policies and production controls.Each adopted app, its integration and ongoing maintenance.Whatever oversight the company separately establishes.
ImplementationTeams 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.
PermissionsThe 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.
VisibilityShared 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 breaksShared 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 buildMore 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 ↗
01 / THE UNIT

An app of its own

Each app deploys on its own and has a named owner, versions and a lifecycle.

02 / THE AGREEMENT

Declared permissions

Agree what an app may do. The platform enforces that boundary.

03 / THE REVIEW

Exercise the app

Run the app instead of reading it. appfuzz is one way to automate that.

04 / THE RUNTIME

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.

As a native process, an app written by marketing reaches everything: it can update orders, flood the network, delete files in /data, fork processes without limit, and read and write items.NATIVE PROCESSreaches everythingpromo_bannernative · uid wwwordersread · writenetworkany hostfilesystemall of /dataprocessesno limititemsread · writeUPDATE orders10k req/srm -rf /datafork() ×∞SELECT itemsThe same app as WebAssembly in a shell reaches only items.get. Orders, network, filesystem and processes are not granted, so its calls to them are blocked.WASM IN A SHELLreaches items.getpromo_bannersame app, as .wasmordersnot grantednetworknot grantedfilesystemnot grantedprocessesnot granteditemsgranteditems.getWASM shellwasmtime · 64 MiB · metered

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.

Browserpeople from every teamIdentity providerOIDC · proxy · pluginsign-in only, never per requestappos CLI / agent$ appos review → appfuzz$ appos deployapp.zip + tokenPlatform teambrowser on /adminappos-shellone Rust process · tokio · axumOWNED BY ENGINEERINGPUBLIC LISTENER --addrSessionsigned cookiePolicycasbin · policy.csvRouter/<app-id>/… · layout · menu · htmxHTTPSwasmtime 50· one Engine · fuel + epoch interruption, 10 ms tickper request: a fresh Store + instance from InstancePre · 64 MiB · 2 s · fuel 1 Gstart(handler, req)webinarsRustapp.wasmpricingZigapp.wasmstatusTypeScriptapp.wasmeventsJavaapp.wasmyour appGoBYO toolchainyour appOdinBYO toolchainWIT host calls: registry · page · log · kv · only if grant ∧ policyWASI 0.2: io · clocks · random · cli. Nothing else links. Apps never see the user.kv transactionbuffered · OCC, rerun ≤ 10×kvcost per requestload · swapPLATFORM LISTENER --platform-addrPlatform API/_platform/* · tokenAdmin screen/admin · policy: adminDeploy & stateBundle::checked: manifest + import checkversions · rollback · auto-rollbackkill switch · pause · freeze · stop allusage meter, batched off the request pathone transaction per changeDATA DIR --dataappos.dbSQLite · all apps' kvplatform.dbversions · events · usageapps/<id>/<v>/app.zipevery version kept
Browserevery teamIdentity providerOIDC · proxy · pluginappos-shellRust · tokio · axumHTTPSsign-in onlyPUBLIC --addrSessionsigned cookiePolicycasbin · policy.csvRouter/<app-id>/… · htmxstart(handler, req)wasmtime 50· fuel + epochfresh Store + instance per requestwebinarsRustapp.wasmpricingZigapp.wasmstatusTypeScriptapp.wasmeventsJavaapp.wasmyour appGoBYO toolchainyour appOdinBYO toolchainhost calls: registry · page · log · kvonly if grant ∧ policyWASI: io · clocks · random · clikv transactionbuffered · OCC, rerunload · swapDATA DIR --dataappos.dbapps' kvplatform.dbhistoryapp.zipper versionDeploy & statechecked bundle · versions · rollbackkill switch · freeze · usageone transaction per changePLATFORM --platform-addrPlatform API/_platform/*Admin screen/adminappos CLI$ appos review$ appos deployPlatform teambrowser on /admin
How a request and a deploy move through AppOS. Yellow-topped apps use a supported language; dashed ones bring their own toolchain.
AppOS / architectureWasm component model · WASI 0.2 · wasmtime 50
01Sourceany language that emits a component

Supported · appos build compiles it

  • Rustcargo · wasm32-wasip2
  • TypeScriptscriptc, AOT
  • Zigwasm32-freestanding
  • JavaMaven · TeaVM

Not supported · bring your own toolchain

  • GoTinyGo · wasip2
  • C / C++wasi-sdk · wit-bindgen
  • MoonBitwit-bindgen moonbit
  • Odinfreestanding_wasm32
  • ElixirOrb · wasm-tools
  • Yourswasm-tools component new

Not tested by us. Loads if its imports ⊆ appos:framework ∪ wasi:{io, clocks, random, cli}.

↓ compiles to one artifact
02Artifactthe contract and the manifest
// 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"]
↓ appos deploy
03ShellRust · owned by engineering
Edgeaxum + htmxsign-in: OIDC · proxy · Wasm plugincasbin: who may use which grant
LoadComponent::new, onceimport check against the grantskv linked only if grantedinstantiate_pre
Per requestfresh Store, fresh instancefuel 1 G · memory 64 MiB2 s wall clock, 10 ms epoch tickI/O budget 100: read 1, write 5
WASI 0.2, empty context✓ io · clocks · random · cli✗ filesystem · sockets · httpany other import: rejected at loadno env, no preopens; stdout → app log
StateSQLite; kv private to each appwrites buffered until page.doneread conflict → rerun alone, ≤ 10×denied host call → nothing written
Admins tune limits per app: memory 16–512 MiB · fuel 250 M–8 G · time 1–30 s. Up to one request per core per app, then a 10 s queue, then 503.

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.

TIMEMEMORYCPU FUELI/O
The team’s appFRESH SANDBOX
App grant
+ user policy
BOTH MUST ALLOW
App dataHOST CAPABILITY
CALL ALLOWED

The app may read, and so may this person. The platform returns the app’s data.

INTERACTIVE ILLUSTRATION / A READ-ONLY APP / NOT A LIVE REQUEST

AI code needs to pass more checks.

AuthenticationPassword ok?ApplicationOne userAuthenticationPassword ok?AuthorizationCan token do X?ApplicationIndividual usersAuthenticationPassword ok?AuthorizationCan user do X?AuthorizationCan token do X?AppIndividual usersAuthenticationPassword ok?AuthorizationCan app do X?AuthorizationCan user do X?AuthorizationCan token do X?AppIndividual usersMost teams todayDevelopers write the code, we trust itAppOSMarketing codes the app with AI, we check every call
AuthenticationPassword ok?ApplicationOne userAuthenticationPassword ok?AuthorizationCan app do X?AuthorizationCan user do X?AuthorizationCan token do X?AppIndividual usersMost teams todayDevelopers write the code, we trust itAppOSMarketing codes the app with AI, we check every call
ONE WASM CONTRACT / DIFFERENT SOURCE LANGUAGESRustTypeScriptZigJavaSee the boundary ↗

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.

Kitewell / pricing-zig
Actual Kitewell pricing calculator showing Starter, Team and Business plans.

MarketingZig → WebAssembly

Pricing calculator

Team size, billing and add-ons become a clear price. Customers use it, and it stores nothing.

APP GRANTS / No storage grants

“People keep asking which plan they need. Let them work it out themselves.”

Paraphrased from the original brief. Working example app; Kitewell and its data are fictional.

Kitewell / webinars
Actual Kitewell webinars app listing upcoming sessions and registration links.

MarketingRust → WebAssembly

Webinar registration

It handles registration, seat limits, a waitlist, cancellation and attendee reporting, built around the events team’s workflow.

APP GRANTS / kv-read · kv-write

“We overbooked the last workshop. Give us seats, a waitlist and one place to manage it.”

Paraphrased from the original brief. Working example app; Kitewell and its data are fictional.

Kitewell / discounts
Actual Kitewell discount desk with requests, approval status and sales workflow.

SalesRust → WebAssembly

Discount approvals

Reps request discounts. Policy determines the approval chain. Decisions and the numbers stay on record.

APP GRANTS / kv-read · kv-write

“Discount approvals happen in Slack DMs. Nobody knows what was actually approved.”

Paraphrased from the original brief. Working example app; Kitewell and its data are fictional.

Kitewell / status-ts
Actual Kitewell status page with component status, uptime and incident history.

Customer successTypeScript → WebAssembly

Customer status page

Support publishes incidents and maintenance. Customers see current status, updates and the last 90 days.

APP GRANTS / kv-read · kv-write

“Every incident brings the same question: is it down? Let customers check for themselves.”

Paraphrased from the original brief. Working example app; Kitewell and its data are fictional.

Screenshots of the real example apps running locally. Kitewell is fictional. Explore all four apps and their original requests ↗

ILLUSTRATIVE IDEA / LEGAL

A contract intake tool.

Help colleagues submit the right information before a legal review.

ILLUSTRATIVE IDEA / CRO & REVENUE

A tool to test a new offer.

Turn a revenue experiment into something customers can try.

ILLUSTRATIVE IDEA / OPERATIONS

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.

Rust, TypeScript, Zig or Java. One WebAssembly contract.

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 AppOS admin console: four apps from Marketing, Sales and Customer service with their limits, live requests per minute and failures, and the controls to roll back, limit or turn off an app.

The real AppOS admin console, with fictional example apps and temporary demo data.

Roll back a version

Keep immutable app versions and make an earlier one live.

Contain repeated failures

Automatic rollback when the live version repeatedly fails.

Set a boundary

Adjust per-request time, memory and instruction limits.

Take control

Stop an app, freeze deploys or stop all apps.

GARDENING / RUST APPS TODAY

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.

Dependency
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.

Pilot one app, then grow the platform from there.