How Can Marketing Ship to Production?
AppOS architecture, learning from your phone
Stephan Schmidt · Amazing CTO
How can marketing ship to production?
Many orgs face the reality of everyone vibe coding
Engineering is the new bottleneck for reviews
Agents write more code than senior engineers can review
Saying no doesn't work, people deploy to Vercel on their own
How can engineering feel safe and trust the code?
Everyone coding is the biggest lever for productivity and time to market
Your iPhone has solved this
You trust code from unknown developers with your bank account
iOS and Android have app permissions
apps only do what they are allowed to do
apps run in a sandbox
App Store review checks apps for bad or malicious behavior
AppOS Principles
Adapt that model to applications: apps written by marketing, a shell/kernel owned by engineering
Possible architectures
WASM gives the strongest isolation inside one process
Plugins and modules are easier, but the language has to hold the boundary
Services put a network between app and shell, a gateway checks permissions
App
Permissions
Apps do only what
their manifest grants
Automatic
App Review
Every app is checked
before it runs
App /
Unit
Marketing ships
one small unit
Sandbox /
Harness
Each request runs
inside hard limits
From marketing code to production
Negotiate
manifest
Marketing
codes
Use AI to write the
app against the API
Automatic
app review
Check code
Check manifest
Deploy
check
API check
Runtime
sandbox
Runs in production
Permission checks
at runtime
AppOS architecture
Browser
Shell / Kernel
App
App
App
1
2
3
IO, e.g. database
1
App permissions
2
App in sandbox
(CPU, memory)
3
Manifest file
Proven approach
Securely running unknown code
Start a fresh sandbox on each request
Fastly Compute
A fresh WASM instance per request
Shopify Functions
Apps' WASM runs in every checkout
Cloudflare Workers
WASM modules, each in its own isolate
Bunny Edge Scripting
WASM built in, each script isolated
AWS Lambda
WASM if you ship a runtime like wasmtime
AI code needs to pass more authorizations
Authentication
Password ok?
Application
One user
Authentication
Password ok?
Authorization
Can token do X?
Application
Individual users
Authentication
Password ok?
Authorization
Can user do X?
Authorization
Can token do X?
App
Individual users
Authentication
Password ok?
Authorization
Can app do X?
Authorization
Can user do X?
Authorization
Can token do X?
App
Individual users
Most teams today
Developers write the code, we trust it
AppOS
Marketing codes the app with AI, we check every call
Permissions
Every app declares capabilities like pods-read or bookings-write in its manifest
The manifest is negotiated: nobody approves permissions one by one
A deploy that uses an API not in the manifest is refused
Roles still apply: an app with pods-write doesn't let Alice write if she is not allowed to
Business rules stay in the platform, like one booking per pod and hour
People only review the permissions
App
permissions
User
permissions
Can the booking app
read pods?
Can Alice
read pods?
Automatic App Review ("Hardening")1
Every app is checked before it runs
manifest, host function catalog and the code
Quality before malice:
Apple rejected 1.93M of 7.77M apps in 2024, 1.24M for crashes and bugs, ~43k for hidden features
Fuzzing with fake host functions: appfuzz
Finds crashes, n+1 queries, corrupted data, security holes and "DDoS"
Pass or fail on every deploy, no human bottleneck
fail: the version is refused, the old one keeps serving
warn: it goes live, its findings are shown
It catches mistakes early, the sandbox still enforces every rule
Apple, App Store Transparency Report 2024
Runtime Sandbox ("Harness")
Each request runs in a fresh sandbox without files, network or a database of its own
The app reaches the world only through the host functions its manifest grants
Every call checks the app's grant and the user's role
Every request has a budget for I/O, time, CPU and memory
Over budget, the app's slot shows unavailable and the page still renders
App pages run their own JavaScript; the shell's CSP keeps scripts on the app's origin and approved hosts
A broken app can't take down the shell or other apps
Gardening
Everyone deploys: the CEO to Vercel, a marketer to Fly.io
Shadow apps keep running and hold data, but nobody knows about them or patches them
With AppOS we know what runs, who owns it and what it may do
Every app has an owner, and when they leave the app is handed over or switched off
Every manifest is written against one API version
Manifests expire after 90 days and the app has to be reinstalled
Unused permissions are flagged and removed
Roomer already shows versions, usage and one-click rollback per app
Side effect: WASM makes us much more secure1
Everything gets hacked, every month
many attacks come in through npm packages, CI and vendors
A hacked library inside a WASM app finds no files, network or environment variables
it can't read secrets and has nowhere to send them
It can only call the host functions the manifest grants
and every call is checked against the user's role
Injected markup is caught before deploy: appfuzz runs every page's scripts
The sandbox limits what hacked code can do, in our own dependencies too
@buildwithsid on X, 31 October 2026
Roomer: AppOS in practice
Roomer books office pods for meetings or quiet work
Engineering owns the shell with sign-in, layout, data and permissions
Agents wrote four apps on top
Booking grid and Quick book for Product
Pod stats for Marketing
Pod admin for the Platform team
Each app is handed over as one .wasm with its manifest
Roomer example AppOS architecture
Example app: Booking grid
Book a pod in three steps: pick a pod, pick your hours, confirm
Written by an agent for Bob from Product, shipped as one .wasm
Bob can optimize, A/B test, layout changes, add features safely without engineering
Shipped without a manualcode review, the worst case is a wrong booking
Its manifest grants four permissions:
pods-read: list the pods
bookings-read: the day's bookings and bookable hours
bookings-write: book a pod, cancel only your own bookings
identity: who is booking
See running apps and permissions
WASM under the hood
Built with cargo for wasm32-wasip2
WebAssembly components of 55 to 150 KB
One export: request in, HTML out
At deploy the shell checks the imports against the manifest
A component lists the WIT interfaces it imports
Any import the manifest doesn't grant is refused
Each request gets a fresh wasmtime instance
Linked only to granted interfaces, no files, network or environment
Casbin checks every call: the app's grant and the user's role
Budget of 100 I/O units, 200 ms, 64 MB and CPU fuel, 8 parallel requests per app
interface pods-read {
all: func() -> list<pod>;
}
interface bookings-write {
create: func(pod-id: u32, date: string, hour: u8,
subject: string) -> result<booking, string>;
cancel-own: func(id: u32) -> result<_, string>;
}
world app {
import pods-read;
import pods-write;
import bookings-read;
import bookings-write;
import identity;
import log;
export handler;
}
WASM is fast enough: 16,700 requests per second on one core, JSON in, HTML out, with a fresh sandbox for every request.1
Ryzen 9 3900X, wasmtime 50, Rust → wasm32-wasip2, 147 KB component, fuel and 64 MB limit, 57 µs median, 86 µs p99
Prior art
Java platforms
OSGi: bundles declare imports in a manifest, checked before anything runs
Portlets: the portal owns the page, each portlet renders a fragment
EAR: deployment descriptors declare security roles, the container enforces them
App stores and marketplaces
Browser extensions: declared permissions and store review
Atlassian Forge, Shopify, Salesforce: apps inside someone else's product
Cloud platforms
Firebase: untrusted code is fine if the rules hold
Fastly, Cloudflare Workers, Bunny, Lambda: a fresh sandbox per request
WASM component model: capabilities as interfaces
Portals taught us the platform should own the page. OSGi taught us to check dependencies before anything runs. App stores taught us to review the submission up front.
What AppOS doesn't solve
Content, design and SEO stay with marketing
New APIs still need engineering
Schema and integrity rules stay with engineering
An app can misuse what it is granted, like booking pods nobody needs
Apps can't call third-party services unless the shell offers an API for them
The shell team becomes a platform team
Where to start
Pick one app marketing wants to ship
Marketing and engineering write its manifest together
Put a shell in front that owns sign-in, layout and data
Start with the import check, then use appfuzz1
Engineering reviews the manifest instead of the code
appfuzz.dev
About Stephan
Coding for 45 years , since 1981: from Z80 machine code to Rust
Serial startup founder, engineering manager, CTO of an eBay Inc. company
Studied artificial intelligence at university in the 90s
CTO coach at Amazing CTO, 1200+ coaching and sparring sessions
amazingcto.com