Automation Playbook

Five pipelines. One content engine.

A forward-looking proposal by Matthew O’Hair for moving content from brief to release, grounded in shipped Bearing Fruit workflows and artifacts.

Proposed workflow · Operator experience

You direct the work. The system carries it forward.

A content lead gives direction, follows the run, and makes the decisions that require judgment.

01

Give direction

Set the goal, sources, outputs, audience, and release rules.

Content operations

What should the platform make?

Goal
Create a five-day Easter experience for families and prepare every approved output for release.
Source material
Sermon transcript + Scripture references
Outputs
DevotionalNarrationArtworkShort video
Settings
Families · Easter · English · Human release gate
Start tracked run
02

Follow the run

See completed work, the current owner, and the next decision in one tracked run.

Content operations · Run view
GLG OpsRunsReview queueLibraryReleasesPolicies

Easter family experience

Run 0184 · started by CMS webhook · 12 minutes ago

1 decision needed
Requested outputs4 connected deliverables
Current ownerHuman review queue
Sources, rights + references validatedsource.validated
Draft + automated reviews completedreviews.completed
!One editorial exception needs judgmentreview.required
·Narration, artwork + video generationpaused
·Release verificationpaused
03

Decide and approve

Approve a revision or request changes without starting another prompt chain.

Review queue

A decision, not another prompt

Scripture reference check

Confirm the interpretation before release

The accuracy review found language that may overstate what the cited passage says.

Proposed: “Courage means we never feel afraid.”
Suggested: “Courage helps us act faithfully even when we feel afraid.”
Impacts devotional + narrationVideo waits automatically
Request changesApprove revision

How I would build it

Start with one pipeline, end to end.

First prove the operating model with Content + Audio, using Bearing Fruit’s existing delivery workflow. Then measure it and extend the same pattern to the other pipelines.

  1. Define the shared rulesEstablish the sources, policies, run record, approval gates, and release requirements.
  2. Pilot Content + AudioConnect intake, drafting, review, narration, staging, and publication in one tracked run.
  3. Test failure and recoveryVerify that approvals, retries, timeouts, and corrections resume safely without losing context.
  4. Measure, then expandMeasure time, cost, approval cycles, and recovery before extending the pattern to visual production, video, engineering, and UI verification.

The five pipelines

Each pipeline has one clear job.

Each card separates current evidence from the proposed workflow; compact event labels show what advances each run.

Arrow labels name the API, event, queue, rule, or automated job result that advances the run.

What moves the work: each completed step saves its output and emits a named event. Inngest reads that event and the stored run state to advance, wait, retry, or route the next job; adapters translate third-party results into the platform’s events.

01

Content + audio

One orchestrated run can begin with a person or an automated request, then move from validated sources to published content.

Guardrailsvoice + editorial guide, rights + Scripture policy, audience and release policy

Existing proof

Live devotional + narration manifest

A live manifest already delivers content and narration.

This versioned entry tells Bearing Fruit what to show and which narration to load. Updating it does not require another app release.

Sanitized live entryView manifest ↗
{
  "devotionalId": "the-enemys-strategy",
  "title": "The Enemy's Strategy",
  "audioUrl": ".../v1/en-us-f.mp3"
}
Read the published transcript

The Enemy’s Strategy. Why you don’t pray.

Prayer is often resisted in unremarkable ways. You get busy. You get tired. You feel dull. You feel ashamed. None of that looks dramatic, but it still keeps you from turning to God.

Scripture teaches that we do have a real enemy. Ephesians chapter six says we wrestle against more than flesh and blood. First Peter chapter five tells us to stay watchful. So it should not surprise us that prayer, one of the clearest expressions of dependence on God, often feels contested.

Prayer is where we stop pretending to be self-sufficient. It is where we confess need, ask for help, and wait on God’s strength instead of our own.

The four lies that keep us from prayer.

The first is busyness. The lie says, “I have too much to do.” The truth is that need does not decrease when life gets full.

The second is dryness. The lie says, “I do not feel anything.” The truth is that prayer is not invalid when it feels dry.

The third is pride. The lie says, “I can handle this.” The truth is that prayerlessness often says, in our actions, “God, I can do today without You.”

The fourth is shame. The lie says, “I should wait until I am doing better.” The truth is that Jesus is the reason you can come near now.

How do you answer those lies? Pray anyway.

Stop. Turn toward God and say, “Father.” You need only honesty and a real turning of the heart toward Him.

Practice this today. Do a simple audit. Which lie is loudest today: busyness, dryness, pride, or shame? Name it before God. Refuse to let it have the last word. Then pray anyway. Even if all you can say is, “Father, help me.”

Proposed workflow
submit brief + source material
brief.submitted
load the submitted source + run profile
schedule, CMS webhook, or coverage signal requests a run
run.requested
find possible sources + load the run profile
validate source, rights + required metadata
source.validated
plan → draft + evaluate → revise ↻
reviews.completed
apply deterministic routing rules to findings + policy
review.required or draft.ready
resolve a flagged exception
or
continue when no exception exists
draft.ready
approve the completed draft
draft.approved
generate the content package + narration
outputs.ready
stage + verify URLs, manifest, and package
release.ready
approve the staged release
release.approved
publish + verify live delivery
publish.verified
store results, corrections + performance signals

The run record makes every retry, pause, approval, output, and event inspectable.

02

Visual + marketing production

One production flow can create in-app art, app-store listings, campaign graphics, and social images, adding copy only when the selected destination needs it.

Guardrailsvisual brief, brand direction, rights record, destination specs

Existing proof

Editable PSD + six App Store exports

An agent built an editable master and six published iPad App Store images.

The run captured product states, constructed editable Photoshop groups and copy, and exported six 2048 × 2732 RGB files. A person then made the final pixel-level adjustments.

Finished Bearing Fruit iPad App Store garden image
Editable scene master
Sanitized Photoshop panel showing scene groups, editable text, device frame, screenshot, and shadow layers
Layer groups + editable type

Photoshop JSX builds the scene groups; the export worker generates the release set.

Six published Bearing Fruit iPad App Store images
Six published iPad App Store outputsBearing Fruit on the App Store ↗

Agent-run: app-state capture, editable PSD construction, copy placement, and export set.

Human gate: final pixel-level art direction and approval before store submission.

Proposed workflow
set the creative direction + destinations
creative.requested
generate and edit visual options
images.ready
read destination specs + route copy when required
copy.requested or masters.requested
draft + refine copy
or
continue without copy
masters.requested
build editable masters + device and locale variants
exports.ready
check dimensions, formats, safe areas, copy + rights record
creative.passed
review + approve the release set
creative.approved
stage the package in a reviewable destination state
destination.ready
approve submission or release
delivery.approved
submit, integrate, or publish to the selected destinations

Store builds and creative can upload automatically while submission or release remains an explicit human gate.

03

Product engineering

One tracked run can move a product change through agent implementation, cross-platform verification, signed builds, store review, staged rollout, and monitoring.

Guardrailsarchitecture, test policy, signing controls, release policy, rollback thresholds

Existing proof

Cross-platform version alignment check

One version record already keeps the mobile targets aligned.

Bearing Fruit 1.3.0 is live. The repository check fails when app metadata, package files, Gradle, Info.plist, Xcode project settings, or the in-app version fallback disagree. Production EAS profiles are defined for both platforms.

Sanitized release checkPASS
release             1.3.0
ios_build           63
android_version     63
eas_profiles        preview | production | ios-testflight
version_check       OK across app, Gradle, plist + Xcode
one release versionplatform configs synchronizedmismatches block the run
Proposed workflow
approved issue, release plan, or monitored defect requests a run
engineering.requested
plan, implement + use repository and test tools to repair failures ↻
code.ready
run lint, type, unit, build + security checks
checks.passed or repair.requested
invoke UI Verification with the affected journeys
journey.passed or repair.requested
assemble the version, release notes + risk summary
release.plan.ready
build + sign the iOS candidate
and
build + sign the Android candidate
build adapter records both results → builds.ready
validate versions, signatures, policies + artifact record
packages.passed or repair.requested
stage builds in TestFlight + the Play internal track
stores.ready
approve review submission + rollout policy
submission.approved
submit both candidates for store review
store adapters wait for review.approved
begin the configured phased or staged rollout
release.live, release.blocked, or review.required
monitor crashes, store state + product signals
rollout.updated or threshold.breached
summarize rollout health + recommend promote, hold, or halt
pause or halt supported rollouts; otherwise create rollout.review
store the release record, decision history + rollback target

Planned execution layer: Inngest owns workflow execution state; the application keeps the durable run record; GitHub Actions records code checks; EAS Workflows runs builds and submission jobs; store adapters report review state and manage supported rollout controls.

04

UI verification

App journeys run themselves on iOS and Android; failed runs produce evidence before a person or agent decides what to change.

Guardrailsflow contracts, stable test IDs, seeded app state

Existing proof

Maestro failure → passing rerun · iOS

A failed journey produced the evidence for a passing rerun.

The runner found the reminder control but the schedule modal did not open. Its screenshot and command report exposed the missing interaction; after an explicit swipe was added, the same journey passed 12 minutes later.

Bearing Fruit reminder card captured when the Maestro journey failed to open the schedule modal
Failure capture: the reminder card remained on screen instead of opening the modal.
08:56 · Failedscreen.reminderSchedule.modal was not visible.
- swipe: 50%,80% → 50%,45%
- tapOn:
    id: habitDetail.completionReminderCard.schedule
- assertVisible:
    id: screen.reminderSchedule.modal
09:08 · PassedSwipe, tap, and final modal assertion completed.
runner exits failedscreenshot + report savedflow adjustedrerun passes
Proposed workflow
PR update, release candidate, schedule, or manual request
test.requested
select affected journeys + seed profile
journey.run
seed test state + run the Maestro journey
test.passed or test.failed
capture screenshots + logs
evidence.saved
Pass
emit journey.passed + resume the calling run
Failure
analyze evidence + use code and test tools to propose a fix
triage.ready
approve a fix, change the test, or accept the result
approved fix or updated journey → test.requested ↻

The runner’s exit result selects the pass or failure route and can resume Product Engineering.

05

Short-form video

Agents draft the script and storyboard; the media step is either generated or captured, depending on where the video is going. Automated workers assemble, caption, and check the package before release.

Guardrailsbrand direction, rights + Scripture policy, destination content rules

Existing proof

Storyboard → spec-validated App Store preview

The destination decides whether media can be generated at all.

Apple requires app previews to show only content from within the app, so the App Store slot cannot be filled by a generative model. That branch of the pipeline captures instead: a seeded demo profile, Maestro driving the app, and one screen recording per storyboard beat. Shared frame guards assert the shot list's “must not appear” rules on every recorded beat, so a coachmark or toast fails the beat before a frame reaches the renderer.

Captions and the end card composite over that footage in Remotion; an ffmpeg pass muxes to Apple’s exact delivery spec, and an ffprobe gate rejects anything off it. Any single beat is re-shootable without redoing the run, and caption iteration needs no simulator at all.

CaptureSix beats, each re-seeded, guarded, and measured into capture-manifest.json.
PASS  width              886
PASS  height             1920
PASS  video-profile      High / 4.0
PASS  frame-rate         30.000fps <= 30
PASS  audio-stream       silent stereo AAC present
PASS  duration           24.60s within 15-30s
GateNon-zero exit on any violation. publishable stays false — upload and poster frame are human.
storyboard as dataguarded per-beat capturecomposite + finalizespec gatehuman publish
Proposed workflow
submit the video brief
video.requested
draft and refine the script + storyboard ↻
storyboard.ready
approve the script + storyboard
storyboard.approved
read the destination’s content rules → route the media step
shots.generate or shots.capture
generate shots + narration (social)
capture shots from the seeded app (app store — in-app footage required)
media.ready
assemble, caption + validate the video
video.passed or revision.requested
review the final video
publish.approved
publish the approved package

The technical foundation

One run record keeps the pipelines connected.

The shared record preserves context, artifacts, checks, approvals, and the next action.

Shared context

Sources, rights, policies, and release plan.

Application-owned run record

Completed and active steps, produced files, checks, approvals, and costs.

Next action

Advance, wait, retry, or roll back.

One exact handoff: Product Engineering starts UI Verification, waits for journey.passed, then resumes the same tracked run with the shared context intact.

Current proof: LLM agents, Gemini, ElevenLabs, Photoshop, Maestro, and Cloudflare R2. The proposed execution layer adds Inngest while the application’s run record remains the durable source of truth.

Production safeguards: access, secrets, safe retries, provenance, audit history, monitoring, retention, and rollback. Agents, CI, media workers, and product integrations perform the work.

Explore the Content + Audio orchestration schematicOptional technical detail

In the proposed execution layer, Inngest owns workflow execution state and consumes named events to start, wait, resume, or retry work. The application saves the canonical run history, artifacts, approvals, and business state; adapters report third-party state and emit platform events. Every event carries a run ID, and approval events bind to the reviewed artifact hash.

Actor / phase
Human
Inngest
+ agents
Systems
+ data
1 · Start
Submit brief + source material
human sourcediscovered source
Application creates an idempotent run record; Inngest queues source loading
Schedule, approved CMS update, or topic-coverage signal
Find and pull possible sources
2 · Prepare

A person is contacted only when required source information is missing.

Source loader emits source.ready
Load the selected run profile
Validate source, rights + required metadata
Check Scripture references, duplication + topic coverage

Feeds validation and creation

Run profile: audience, outputs, locale, voice, review policy + release target
Guardrails: editorial voice, rights, Scripture, audience + release rules
3 · Create + review
Every passed draft becomes a review task
Mandatory: approve the draft, request changes, or reject it

draft.revision.requested carries reviewer notes back to the loop; rejection ends the run.

Inngest consumes source.validated
Agent iteration loop↻ until thresholds pass or retry limit
Plan
Draft + edit
Parallel reviews: voice, accuracy, safety, rights + duplication
Revise
Routing rules consume reviews.completed
Correctable findings → draft.revision.requested → agent loop
Thresholds pass → draft.review.required → mandatory human review

Feeds the agent loop + routing rules

Validated sources, citations + pronunciation dictionary
Quality thresholds, prior corrections + evaluation cases
4 · Produce + release
Verifier emits release.ready
Mandatory: review the staged package and approve release

A reminder precedes timeout; timeout rejects the release.

Inngest consumes outputs.requested
Fan out only the selected outputs
App contentLocalizationNotificationsVideo / social brief
Narration branch
Synthesize→ audio.readyAlign + automated QA→ audio.passed
Output workers emit outputs.ready after checks pass
Build package + manifest; validate schemas and assets
Stage + smoke check
Publish only after release.approved; verify live delivery
Keep previous version for rollback
5 · Learn
Add corrections or change content priorities
Publisher emits publish.verified
Classify failures + topic gaps
Create a next-run or revision request
↺ Inngest schedule + policy rules may enqueue run.requested
Engagement, quality + delivery signals
Corrections and failures become evaluation cases

Metrics can suggest work; they never rewrite theological or editorial content on their own.

Inngest keeps execution moving and pauses at durable waits. The application preserves sources, artifacts, decisions, approvals, and run history.
Visual + marketing production orchestration schematicComing soon
Product engineering orchestration schematicComing soon
UI verification orchestration schematicComing soon
Short-form video orchestration schematicComing soon

From proposal to proof

See the shipped foundation.

Bearing Fruit and the Good Life Games portfolio show the products and workflows behind this proposal.