
Not Everything Belongs in the Cloud: Designing Auren with AWS
How I’m designing Auren so live production keeps running when the Internet doesn’t—using AWS for synchronization, identity and distributed services without putting the show’s critical path in the cloud.
Series: Building Auren: Engineering for the Real World (1 article)
- 1Not Everything Belongs in the Cloud: Designing Auren with AWS This article
Halfway through a live event, the Internet connection disappears. The current slide is on the main screen, lyrics are being sent to a stage display, a video is queued, and local automation is coordinating other systems in the room.
What should the audience notice?
Ideally, nothing.
The application can report that it is offline. Account synchronization can pause. Telemetry can accumulate locally or be dropped according to policy. Online search and collaboration can become temporarily unavailable. None of that should blank the screen, stop prepared media, disconnect NDI outputs, or prevent the operator from advancing to the next slide.
That scenario has become one of the architectural tests for Auren, a presentation and live-production system I am building for churches, conferences, events, and other environments that depend on multiple video outputs, stage displays, media playback, NDI, local automation, show-control integrations, rundowns, shared content, and remote control.
Auren is still in development. The boundary described here is the direction I am evaluating and implementing, not a report from a finished product. I expect some details to change as the renderer, synchronization model, and cloud services meet real testing.
The rule itself is unlikely to change:
Cloud where it adds value. Local where failure is not an option.
Why I drew the boundary here
I did not start Auren because I thought the existing tools were bad. ProPresenter is an excellent application, and it has set a high bar for presentation software used in live production. In my own use, however, it became heavier than I wanted for a machine whose first responsibility was keeping content on screen. Some services and content features were irrelevant to my workflow, and I wanted a runtime in which optional capabilities could be kept farther away from the presentation engine.
I also used FreeShow and found several of its ideas useful. During events, though, I experienced performance and stability problems that made me reconsider the architecture I wanted for this project. Its use of web technologies was part of that reflection, but I do not treat “WebView” as a diagnosis by itself. A native application can be unreliable, and a web-based application can be engineered well. My conclusion was narrower: for Auren's latency-sensitive rendering and output path, I wanted tighter control over execution, resources, and failure isolation than I had experienced in my own events.
Those experiences produced the architecture before I had formal terminology for all of it. Later, while studying AWS reliability practices, I found useful names for parts of the problem: fault isolation, static stability, dependency failure, and the separation between control and data planes. These ideas did not cause the original decision, but they helped me test whether it held up beyond intuition.
The path that must remain boring
For a live presentation, I define the critical path as the smallest chain required to turn an operator action into pixels seen by the audience:
Critical path:
Operator action → Local presentation state → Rendering and playback → Display / NDI / stage output → Audience The connection to Auren Cloud matters, but it is deliberately outside that path. Advancing a prepared slide should not require an API call, a fresh authentication exchange, a database read in another region, or a successful telemetry write. Assets needed by the current show should already be local. The presentation state required for playback should already be available to the engine. Critical integrations in the room should use local communication where possible.
This does not mean the entire desktop application has to be a single process. One of Auren's design principles is:
The operator interface can fail. The output cannot.
That sentence is intentionally blunt, but it is not a promise that output can never fail. The operating system, GPU driver, hardware, power, shared memory pressure, or a bad deployment can still create correlated failures. The engineering meaning is that a secondary interface fault should not automatically terminate the component that owns the current rendered state and outputs. The two should not share more of a failure domain than necessary.
The useful boundary might be separate processes with supervision and a narrow local protocol. In other places, a module boundary and controlled resource ownership may be sufficient. I do not want to recreate a distributed system inside one computer merely to make the architecture diagram more impressive. Isolation is valuable only when it reduces the failures that matter more than the complexity it introduces.
Failure domains before deployment models
“Cloud or local?” is too broad a question. The better question is: which failure domain should own this responsibility?
Authentication, team membership, shared libraries, backups, content distribution, and telemetry gain real value from centralized services. Rendering the current frame does not. It gains latency, predictability, and independence by remaining close to the GPU and the media already prepared for the show.
There is a useful, limited analogy to control and data planes. AWS describes a control plane as the machinery that changes and distributes configuration, while the data plane performs the day-to-day function of already provisioned resources. Auren Cloud can take on management-plane responsibilities: accounts, entitlements, library metadata, collaboration, and distribution. The local runtime performs the product's immediate function during an event.
The analogy is not exact. A presentation is not a router or an EC2 fleet, and some actions—editing a slide, for example—can be both management and live operation depending on timing. Still, the distinction exposes a practical rule: a component responsible for executing an already prepared show should retain the state it needs to continue if the management side becomes unavailable.
Local runtime — show execution
- Show state and prepared assets
- Renderer and media playback
- Displays, NDI, and stage outputs
- Critical local automations and show control
Auren Cloud on AWS — management and distribution
- Identity, organizations, and licensing
- Synchronization, collaboration, and shared metadata
- Asset storage, content delivery, and backups
- Telemetry, diagnostics, and update metadata
The two sides exchange versioned data when connectivity is available.
Static stability, translated carefully
The Amazon Builders' Library describes a statically stable system as one that continues working when a dependency is impaired. It may stop receiving new or changed information from that dependency, but previously working behavior continues. In AWS, the examples involve Availability Zones, pre-provisioned capacity, and data planes that do not need control-plane operations during an incident.
Auren is not applying the Availability Zone architecture from that article to a desktop. The reusable principle is preparation before impairment. If a show package, its media, fonts, output configuration, presentation state, and required local integrations are available before the Internet fails, execution does not need to enter a completely different recovery mode. The runtime keeps using known local state; cloud-dependent changes wait.
That is stronger than simply detecting an outage and failing over to a second Internet provider. Redundant connectivity is useful, but it still assumes that a working external path is part of recovery. For the presentation itself, the safer failure behavior is to require no cloud recovery action at all.
It also avoids a dangerous fallback pattern. A cache that is used only during failure is often less exercised than the normal path. A local show store that is always the execution source—whether online or offline—has one normal operating mode. Cloud synchronization updates that source; it does not replace it at show time.
A restrained AWS boundary
One candidate architecture for Auren Cloud starts small.
Amazon Cognito can provide identity for accounts and organizations. An API exposed through Amazon API Gateway with AWS Lambda behind it is a reasonable option for intermittent, stateless operations such as account metadata, entitlements, library indexes, and synchronization requests. That combination is attractive while traffic is variable and the team is small because it reduces server management. It is not a permanent answer to every backend workload. Long-running media processing, sustained predictable traffic, specialized runtimes, or connection-heavy collaboration may fit a container service better.
Amazon S3 is a natural candidate for versioned assets, backups, backgrounds, plugin packages, and update artifacts, with Amazon CloudFront distributing approved content efficiently. The important local rule is that a show references explicit asset versions and downloads them before execution. “The file exists in S3” is not the same as “the file is ready for tonight's event.”
For metadata, Amazon DynamoDB may fit access patterns such as organization-scoped manifests, synchronization cursors, idempotency records, and content-version lookups. I would not choose it before those access patterns are defined. Rundown collaboration, reporting, and relationships among organizations, users, roles, and content may prove more natural in a relational model. The database should follow the data and query model, not the serverless label.
Amazon SQS becomes useful when the cloud has work that must survive a slow or unavailable consumer: asset ingestion, preview generation, diagnostic processing, or other asynchronous jobs. Amazon EventBridge becomes interesting later, when events such as
asset.published or organization.updated have several independent consumers. With one producer and one consumer, a direct call or a queue is easier to reason about.AWS AppSync is worth an experiment if real-time rundown collaboration and subscriptions become central. Its support for versioned data and conflict-resolution strategies could remove some undifferentiated infrastructure. It cannot decide the product semantics, though. Two operators changing the same cue, reordering a rundown, and editing a shared template are different conflict classes; “last writer wins” is not a design.
AWS IoT Core is not in the candidate architecture today. Auren instances will run on machines, but that does not automatically make device shadows, MQTT topics, certificate provisioning, and fleet policies the right abstraction. If Auren later needs large-scale device identity, intermittent remote commands, or managed state across many installations, I can reevaluate it with an actual requirement.
Amazon CloudWatch can observe the cloud side through metrics, logs, traces, and alarms. The local runtime also needs its own bounded diagnostic store. Sending a log cannot be allowed to block a frame, and losing connectivity cannot make the event unobservable to the operator standing in front of the machine.
The result is intentionally less exciting than a diagram filled with service icons. That is a feature.
The disconnected contract
Offline behavior should be specified, not improvised after the first network failure.
When connected: cloud synchronization and online features are available.
When disconnected: local slides, media, outputs, NDI, and automation continue. Eligible cloud changes remain pending until the connection returns.
While disconnected, prepared slides and media continue. Display and stage outputs continue. Local NDI and show-control integrations continue as long as the local network and their own dependencies remain healthy. Edits needed for the active show are saved locally. Cloud synchronization, online search, collaboration, remote services that traverse the Internet, and telemetry delivery pause or degrade explicitly.
After reconnection, the client should not flood the backend with unbounded retries. Requests need timeouts, exponential backoff with jitter, and a retry budget. Mutations that may be repeated need stable operation identifiers and idempotent handling. A timeout does not prove that the server rejected an operation; it may have committed it and lost the response. This is one of the ordinary, unpleasant facts of distributed systems.
The user interface also needs an honest synchronization state. “Saved locally,” “pending upload,” “conflict,” and “synchronized” are different claims. Hiding them behind one green check would make the interface calmer at the cost of making the system harder to trust.
Fault tolerance does not replace preparation
There is a boundary between system resilience and poor operational planning.
Suppose someone requests a song during the event that was never added to the show, and the only available source is an online search. If the Internet is down, Auren may be unable to fetch it. That does not mean the presentation engine failed; the requested input was never inside the prepared failure boundary.
The product should still help: make preparation status visible, verify that referenced media is present, detect missing fonts or files, offer a preflight check, and make offline limitations clear before the event begins. It should not pretend that every external catalog and integration is controllable.
Live-production resilience is partly architecture and partly procedure. A redundant output does not repair an invalid video file. A local cache does not contain content nobody downloaded. The goal is to make the reliable path easy and the unprepared path obvious.
The synchronization bill
Keeping execution local removes a network dependency from the critical path, but it does not remove distributed-systems complexity. It moves that complexity to the boundary between local replicas and the cloud.
Multiple machines may edit the same rundown. A laptop may remain offline for days and reconnect with an old template. An asset may keep the same human-readable name while its bytes change. A user may lose organization access while a machine holds a cached entitlement. A local database schema may change across application versions. A sync retry may arrive twice. A device clock may be wrong.
These cases require explicit decisions:
- immutable asset identifiers or content hashes, plus versioned manifests;
- idempotent mutations and server-side deduplication windows;
- domain-specific conflict policies rather than one universal merge rule;
- migrations that preserve usable local show data;
- bounded storage and cache eviction that never removes assets required by an active show;
- an offline entitlement policy with a defined grace period and a safe renewal path;
- encryption and OS-appropriate protection for sensitive local state;
- compatibility rules between runtime, show-package, plugin, and cloud API versions.
Some collaboration data may tolerate eventual consistency. The current on-air state cannot be reconciled casually from two writers. I expect Auren to distinguish editable planning data from authoritative live execution state, rather than subject both to the same synchronization mechanism.
This architecture also creates more testing work. Auren needs fault-injection tests for connectivity loss during downloads, token expiry, partial synchronization, duplicate messages, corrupt assets, disk-full conditions, UI restart, renderer restart, and version mismatch. “Works offline” is not a checkbox; it is a matrix of states and transitions.
What remains open
Several choices are still experiments rather than commitments. I have not finalized the cloud database model, the collaboration protocol, the process boundary between the operator interface and output engine, or the degree to which AWS AppSync could reduce custom synchronization work. The licensing model must balance legitimate offline operation with abuse resistance without putting license enforcement in the frame-rendering path. Remote control also needs a clear split between local low-latency operation and optional Internet relay.
The next engineering work is therefore less about adding cloud services and more about proving the boundary. I want to test prepared shows under deliberate Internet loss, restart secondary components without interrupting output, verify asset completeness before going live, and model reconnection with duplicate and conflicting operations. The cloud architecture can then grow from measured workloads and concrete access patterns.
Auren will use AWS substantially. Accounts, collaboration, distribution, backup, synchronization, diagnostics, and future services are all stronger when they can operate across organizations and devices. The screen in front of an audience has a different requirement. Once a show is prepared and running, the cloud may coordinate it, enrich it, and learn from it. It should not be the reason it stays on air.
Further reading
Series: Building Auren: Engineering for the Real World (1 article)
- 1Not Everything Belongs in the Cloud: Designing Auren with AWS This article
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article