Build logs for video, content, and asset pipelines that turn small scripts into repeatable systems.
One commit added a channel-setup script and hook translation data. The channel side takes country and language as arguments and scales for free. The content side needs a hand-filled entry per app per language before the renderer has anything to overlay. A note on how deep 'multi-language support' actually goes.
My YouTube uploader already localized hashtags for web-app videos. The native-app branch still attached a single Korean base-tag set to every language. This post covers a fix that had landed in only one of two branches, the 20-line change that closed the gap, and what I still don't know.
I added a daily job that turns blog posts into video scripts and queues them before publishing. On purpose, its only source is the 27 blog posts I actually wrote, so it stops on its own once they are used up. Where to stop the automation turned out to be the real decision.
I moved my web apps and my Instagram bot into their own folders. Moving folders doesn't feel like a code change, but three scripts had the path hardcoded. The fix was five lines. Finding those five lines was the actual work.
I auto-crossposted my short videos to Instagram Reels, and the cover came out as the solid-color intro screen. The offset parameters were ignored for Reels, so I switched to extracting the cover image myself, hosting it, and passing its URL.
My Instagram crosspost pipeline put the same default hashtags on every app. Nothing errored, because the pipeline only checked that tags were attached, never that they fit the app. This post covers generating tags once per app, caching them, keeping the defaults only as a fallback, and what I still don't know.
Told to promote only store apps, I audited four channels and found just one still pushing web apps. Swapping its content pool wasn't enough. Language, price claims, and tone all came along with it, and a running experiment window had to be reopened.
I was auto-generating shorts to promote web apps that give you a result. The question was in the video, but the answer sat behind a link. I switched to capturing the result page URLs directly so the answer appears inside the video, and uploaded the first one.
The launchd job that refreshes the store-listing file, the only grounding source for my auto-published Threads and Facebook posts, had zero runs since it was loaded. The cause was one plist key: Day=1. No errors, not even a log file, so nobody noticed.
My uploader only understood one manifest schema, so web app videos could still get App Store and iPhone app copy. On top of that, links in Shorts descriptions and comments can't be clicked. This post covers the schema support, profile CTA, and dry-run I added.
My Shorts pipeline only looked at view counts, so I added the YouTube Analytics scope and re-authorized. I got average view percentage, watch time, subscribers gained, and shares. Impressions and CTR never showed up. Those are only in Studio.
Adding en/ja to a video pipeline taught me that language is not a parameter you add to the queue. Fonts, metadata, tokens, and the scheduler all demanded it, and what I ended up with is a system where a token file on disk, not the code, decides how far I publish.
In my brand-channel upload pipeline, the only way to know whether the token was still alive was to publish something. The act of checking was itself an irreversible public act. I split out a 22-line script that re-authenticates and prints the connected channel without uploading anything.
I built a pipeline that generates promo shorts for my apps. The first version ran cleanly, but what filled the frame was the app icon, not the app. I redesigned it around real screens, and one step still needs a human hand.
My bot dashboard was built on one rule: status codes lie, so judge by the artifact. The rule is correct and it has caught real outages. Then this morning a job finished in failure and the board stayed green.
A follower time series, a follow ledger, one new action. Tests passed, everything committed. Twenty-four hours later: one died on its first run, one was recording wrong values, one had done nothing at all. The dashboard stayed green the whole time.
The dashboard watching 53 bots was serving three-day-old code. The file was fixed and the tests passed. What was wrong wasn't the code but when it got loaded into memory — and three healthy bots were showing red because of it.
I chased the same auth error for three weeks and built the expiry hypothesis three times. The answer was that there are two stores, and my interactive sessions and my unattended jobs were reading different ones.
An unattended job produced nothing for three days. The dashboard stayed green and the queue looked full. The cause was a single line that only ever picks the first item.
Two unattended jobs died on an auth error for three weeks. Re-login didn't survive the same evening. When I finally captured the credential file at the moment of failure, the token was perfectly valid — the culprit wasn't expiry, it was a stale write-back.
Play Console's app access question has two answers, and the form's own wording made both apply to my app. The real fork only appears after you click 'Yes'.
I built a gate that checks live store copy against what the app really does. It caught things in English, and Japanese and Polish copy walked straight through it.
'Every app has a promo to render' passed. Counting the other direction, 8 of 21 promos reached zero apps.
25 apps were live on the store; my monitor was watching 22. What the missing five had in common wasn't a bug — it was naming. They broke a convention I invented, so they never made it into the candidate list, and nothing ever said so.
In August I fixed the 404 you get when you list a playlist you just created. Four months later the same spot killed a run with a 409. Same cause, different call: the guard was attached to 'the read', not to 'before propagation finishes' — and both forks were carrying the exact same half.
The bot published successfully every day and every log was green. But a five-format schedule had shrunk to three posts. The cause was a single return at the top of a function.
MissingTranslation only checks whether the key exists in the locale file. A value that is still the English original passes. Users in five languages were reading half the app in English, and every metric said fully translated.
The upsert had no on_conflict, so every run poured out 409s. Once that error became the baseline, the real failure sitting in the same log became invisible.
MediaWiki API booleans are true if the parameter is present, whatever its value. exintro=0 cut article bodies to 292 characters, and verdicts built on those 292 characters permanently blacklisted 43 perfectly good topics.
Daily search impressions fell from ~200 to ~2 and the monitor never fired. The threshold sat on a 28-day rolling total, and a rolling total is built to erase exactly the event you want to catch.
Create a YouTube playlist via the API and list its items in the same breath: 404. The real accident comes next — the crash landed before the state save, so the bot was one week away from creating the same playlist again, every week. The fix wasn't a retry. It was not reading at all.
Three duplicate-canonical notices in Search Console. Two weren't defects — they were success signals. The third was real: a 307 was keeping the root as canonical. But the bigger loss was somewhere else entirely.
What my bot pressed to close a modal was a list row's button. Distinguishing by label failed, distinguishing by count failed as well. The third attempt found the real invariant, verified against 15 saved failure screens.
Exit codes lie, so I rebuilt the monitoring board to watch artifact freshness instead. Then one arm of a preregistered experiment failed twice in a row and the board stayed green — because the fallback filled the slot with the other arm every time.
A ledger recorded which topics the bot had already covered. It held 922 entries and the bot had shipped four videos. The other 900 had never been judged — most were excluded because a wiki request failed once.
A pipeline applying the same store copy fix across many apps failed three times in a row on one of them. The lookup was searching app names as a substring, and one app's bundle identifier still carried an old name that happened to be another app's real name.
I audited the store keyword field across 46 apps. Non-Latin locales were consistently short and I assumed the translators had written less. My validator was measuring a 100-character limit in bytes. Of 678 live slots, 216 exceeded 100 bytes and exactly zero exceeded 100 characters.
I ported several apps to another platform and believed I had replaced every reference to the original platform. A full sweep found 127 leftovers, and of the 46 that code actually references, one renders on the screen right before checkout.
A bot driving a physical Android phone failed 8–19% of its account switches for three weeks. I fixed three real defects and the rate didn't move. The actual culprit was a line printed in every log — the bot was tapping a list row's Dismiss button eight times instead of backing out of the screen.
After auditing keywords and descriptions, one more indexed field was left: the 30-character subtitle under the app name. 36 slots were still the English original in Korean, Japanese, Arabic and Hindi stores, and one app used its own name as the subtitle in four locales.
Two weeks ago I added structured data to six content clusters and wrote 're-measure in two weeks.' The baseline was never taken, the daily snapshot was a rolling window I couldn't use, the impressions were attached to a different host than the one I'd worked on, and the second search channel had no dashboard at all.
A summed user count sat one short of the threshold for nine days. It wasn't short — the four slots were the same person. The tell was that four actors were reporting three identical numbers.
The bot ran on schedule every two hours, exited 0, and reported 'no changes' — all of it true. What was wrong wasn't the verdict but the watch list: 21 hand-typed lines that had stopped halfway through the account.
I was sizing up whether to add a tip button. Pulling the numbers, I found the gate's denominator wasn't people at all. The token column held paths, verdict bands, card slugs and share tokens depending on the app - and the culprit was two question marks that let callers overwrite the visitor id.
My watcher script reported four experiments as needing a start, tried to start them, and got 409 on all four. The list endpoint always returns startDate as null — and the platform starts these experiments automatically anyway. Three different errors were telling me the same fact, and I never tried the third one.
Two weeks ago I wrote that my numbers were inflated 3x but the ratios had survived. For most apps that was true. For one app the impression count was off by 48x — and I was picking A/B test candidates on top of it.
Two weeks ago I wrote a post bragging about a headless Chrome pipeline that captures app screens automatically. That pipeline had been crediting itself as a visitor every evening. Here is how I caught it in a table that stores no user-agent and no IP, and why I changed what I count instead of writing better filters.
My bot dashboard flagged three jobs as late. All three were false: the expected period simply didn't match the actual schedule. Meanwhile three rows marked 'no output' were watched by nobody, and one of them had silently skipped a 60-day token renewal.
My shorts bot computes performance scores every day. The top topic scored 4x the runner-up. But one track never read those scores; it walked a hardcoded order instead. Korean and English were set to spend four months on the losing topic.
Asked to scale up my shorts pipeline, I reached for the generation count. First I read the log: it planned three videos a day and quietly dropped two of them as duplicates. The queue never forgets what it already shipped.
Twenty-odd apps share one Supabase project. I counted new signups per app and every app returned 264. An auth trigger was fanning a single signup out into every app schema — and I had already made decisions on that denominator.
I hadn't seen any Android metrics for months — the Reporting API was 403 and the report bucket was 404. Removing `_rev_` from the bucket name returned 200. It was never a permissions problem; I had written a wrong constant into my own notes.
A Threads metric read zero. The cause was that the API hands back a different list than the app screen does — and the real number, once fixed, hurt more.
I shipped write-then-read-back checks across six bots and the synthetic tests passed. Not trusting that, I ran a real write against a live channel — and the read right after the write returned the old value. My checker was ready to report healthy writes as failures.
No inventory, no ad spend, 124 products live on a marketplace in a day. The listing API was the easy part; the risk filter, false positives, and ghost products were not. Gotchas from bulk listing automation.
I'd been pulling app funnels from ASC analytics for months. Cross-checking revenue for the first time, payment counts were off by 6×. The cause was a report that restates the prior three days on every run, and I was summing all of it. The ratios were fine — but one metric that mixed two sources was rotten.
I audited my self-learning loops from first principles. I meant to fix four things — but the most suspicious one turned out to be deliberate by design. The audit's real output wasn't three commits; it was one diff I didn't write.
![Concept diagram: left shows a false alert with a [shorts] prefix accumulating one per day in the log; right shows the real outage happened only once](/img/observability-that-lied/echo.svg)
I traced a 'same-time-every-day 500 error' alert. The real outage happened exactly once. The rest was the monitor writing its own alerts into the log it scans, then re-scanning them. The same day, a dashboard also contradicted itself: 4/4 but 'waiting'. A field guide to the two ways observability lies to you.
Four policy/support pages for one app were another app's stub for four days. Nobody could tell. The domain sits behind Cloudflare, which serves a challenge page with a 200 to non-browser requests — so curl couldn't verify a deploy. The only authoritative check was comparing file hashes over SSH.
A headless follow bot driving a real phone over adb hit a CAPTCHA checkpoint one day. The problem wasn't 'looking human' — it was speed and indiscriminate action. What I turned off and slowed down.
My automation dashboard lit up with 'self-improvement gate fired.' I traced it from first principles and found no code consuming what it learned. Firing wasn't learning — it was logging.
A loop that feeds view performance back into app order, category weights, and retention curves was counting scores from tiny, two-digit-view samples. One minimum-sample gate cut off the noise overfitting.
The whoosh, riser, and pop effects I put on every cut were annoying, so I stripped them all and switched to an unobtrusive music bed. As a bonus, I made thumbnails come from a clean hook frame instead of a random mid-video frame.
adb-driven auto-follow got an account disabled. The cause wasn't volume — it was the synthetic touch fingerprint. Why a real finger passes the same CAPTCHA, and why Threads keeps running fine.
Follow, search-result taps, coordinate actions — the things the official API won't open — driven directly on a real device over adb. And why that's the start of automation, not the end: the CAPTCHA checkpoint.
Zero footage, auto-generated documentary video from self-designed cards plus TTS. The hard part isn't the render — it's the committee gate that blocks ungrounded generation.
A self-learning loop on top of daily auto-posting: recompute content weights from performance, moderate comments conservatively, track growth. Threads plus four Instagram accounts — and the growth paths the API honestly refused to allow.
Building an unattended pipeline that posts to YouTube Shorts (via the Data API) and Instagram (via the Graph API) every day with launchd — the OAuth traps, the media-container polling bug, and how I kept it from becoming spam.
A solo build log: turning a text script into a finished vertical video with edge-tts and ffmpeg, no paid APIs and no manual editing. Plus the honest part — why production was never the bottleneck.
Four ffmpeg and toolchain traps from building a video pipeline: overlay has no alpha, drawtext breaks on non-ASCII font paths, a silently broken system binary, and why a static ffmpeg wins on a recent Python.
MoneyPrinterTurbo and OpenMontage are real, popular open-source projects. But the name oversells them — they automate production, and production was never the bottleneck.