When I started building Solti's bulk audiobook publishing operation, account access looked like a browser problem. Open the right website, stay signed in, and let the worker continue. That is acceptable for one person publishing one title. It is not a safe foundation for multiple catalogs, multiple platform identities, and hundreds of books.
Browsers are designed for convenience. They remember sessions, reopen tabs, and make yesterday’s account feel like today’s account. Publishing systems need the opposite instinct. Before changing an external record, the system must prove which profile owns the book, which platform account is open, and which external record is about to be changed.
The account-isolation problem is not merely “avoid logging into the wrong email.” It is preventing a valid book, a valid platform record, and a valid browser session from being combined in an invalid way.
The convenient-session trap.
A worker can arrive on the correct Google or Spotify page while authenticated to the wrong publishing identity. The title may still exist there. The cover may look familiar. A normalized title search may return a plausible match. Every individual clue can look reasonable while the complete combination is wrong.
This gets more dangerous as catalogs overlap. Similar titles may belong to separate publishers, editions, or profiles. An existing external record in one account is not permission to adopt it into another. A missing record in the expected account is not permission to create one somewhere else.
A remembered session, browser-profile name, open tab, or familiar title may help navigation. None of them proves that the current account is authorized for the current book.
Our design therefore treats account identity as a prerequisite for browser work rather than a detail discovered during it.
Make the publishing profile a real boundary.
A publishing profile should not be a cosmetic filter on a dashboard. It is the operating boundary that groups a catalog with its Google, Spotify, INaudio, storage, defaults, and submission policy.
Each book belongs to one profile. Each platform account binding belongs to that profile. Runs, jobs, observations, platform publications, and operator commands carry the same profile scope. The database rejects cross-profile combinations instead of asking the worker to notice them.
This also changes interface behavior. Switching the visible profile changes the view; it does not silently retarget workers already running in another profile. A Start command applies only to the selected profile. We deliberately avoid an ambiguous cross-profile “Start all,” because a convenient global control can erase the very boundary the data model is trying to protect.
The profile name stays visible wherever operational controls appear. That is not decoration. It answers the operator’s first safety question before a button is pressed: whose catalog am I controlling?
Use three identities for every publishing action.
A safe action combines three different identities:
- The internal book ID. This remains stable when a title, filename, or metadata revision changes.
- The profile and account binding. This says which external publishing identity is authorized for this lane.
- The platform record ID. This identifies the exact Google, Spotify, or distributor record being observed or changed.
Titles and authors remain useful matching evidence, but they are secondary. They help confirm that a platform record makes sense. They do not replace the stable identifiers or authorize a merge when the match is ambiguous.
External identity is scoped to the service, account, and record type. The same external-looking title in another account is a review signal, not a duplicate that the system may automatically suppress. This is especially important during migration, when existing records should be adopted rather than republished—but only into the profile that actually owns them.
Verify the account immediately before mutation.
Configuration stores the expected external account identity and a browser binding reference. It does not store raw credentials in ordinary publishing records. When an operator connects the account, the system reads the platform’s current identity, compares it with the expected identity, and records the verification result and time.
That verification cannot last forever. Sessions expire. Operators sign out. Browser state changes. Account configuration is revised. Before a worker performs a book-scoped action, it checks the current binding revision and re-verifies the observed identity. If either changed, the action stops.
The worker should reserve the profile/account session while it is working so two independent inputs cannot race through the same browser. If the session closes during work or enters an uncertain recovery state, another job cannot simply open a replacement window and continue as though nothing happened.
Failing closed here is inconvenient in the right way. Reconnecting an account takes less time than unwinding a valid submission made under the wrong publisher.
Scope every record, not just the browser.
Account isolation fails if it exists only at login. The job key must include profile and account. The platform publication record must include profile and account. Observations, retries, commands, artifacts, and handoffs must all remain attached to the same scope.
This prevents a subtler failure: a worker verifies the correct account, then consumes an old observation or artifact that belongs to another profile. Fresh evidence is accepted only when it matches the current book, lane, account binding, and relevant revision. Older evidence remains in history but cannot certify new work.
Our action keys include the profile, account, book or publication, operation, and input revision. Repeated discovery can find the same work without creating a second logical action. A changed account binding invalidates stale claims rather than allowing yesterday’s worker to commit an authoritative result today.
The same principle applies to specialist publishing agents sharing one ledger. Different roles may operate each platform lane, but none is allowed to invent or carry account scope only in conversation.
Handle similar titles without guessing.
Bulk catalogs inevitably contain similar names, editions, and subtitles. A fuzzy title match is valuable for building a candidate list. It is not enough for an external mutation.
The matching order starts with a stored platform ID in the expected account. Exact ISBN or other approved edition identifiers can strengthen the match where available. Normalized title and author support review. A similar title alone remains ambiguous.
If the expected account has no confirmed record, the worker must complete the platform’s full duplicate search before deciding that a new record is safe. If a likely match cannot be resolved, the book goes to review. The queue does not pick the closest-looking title because it is late in the day.
After a submission, recovery returns to the same platform ID and account. The duplicate-safe method described in our browser-failure recovery guide depends on this account scope. Reconciliation against the right record in the wrong account is still wrong.
Contain account failures at the account boundary.
An expired authentication session can affect many books, so it appears once as an account issue with links to the affected work. A bad cover or missing chapter is a book issue and should not make the entire account look broken.
When account identity cannot be verified, new external mutations stop for that account. Other profiles can continue if their own bindings and workers are healthy. Read-only information retains its last verified timestamp and becomes visibly stale rather than being replaced with invented current status.
After the account is reconnected, eligibility is recalculated. An enabled worker may resume; a deliberately stopped worker stays stopped. Reconnection does not grant broader publishing scope, replay every missed timer, or turn an unresolved action into a fresh submission.
Test the boundary without overstating the proof.
We have implemented and tested important pieces of this design: profile-scoped records, binding revisions, cross-profile rejection, account-specific sessions, stale-worker rejection, and checks that changed bindings cannot accept old evidence. Those are engineering tests, not proof that every platform account is currently connected or that unattended publication is live.
A complete acceptance test needs two configured profiles with similar book titles. A command for profile A must be rejected if it references profile B’s account, publication, or job. The browser must visibly report the expected account before mutation. Then a real platform pilot must confirm that the same boundaries survive authentication, navigation, and external read-back.
Synthetic tests prove that the guard exists. An authenticated pilot proves that the guard is connected to reality. We need both, and we should label them separately.
The account-isolation checklist.
Before allowing a multi-account audiobook publishing system to change a platform, I would require this sequence:
- Create a publishing profile. Give the catalog one explicit operating boundary and visible owner label.
- Bind each destination account. Store the expected external identity and configuration revision without exposing credentials.
- Assign every book to one profile. Reject records that attempt to cross profile and account boundaries.
- Carry scope into every job. Include profile, account, book, lane, operation, and input revision in the durable action identity.
- Verify the observed account. Compare the live platform identity with the expected binding before any external mutation.
- Match by stable platform ID. Use title and author as confirmation, never as permission to guess.
- Lock the session during action. Prevent two workers or a worker and operator from racing through the same account.
- Invalidate stale evidence. A changed binding or revision requires a fresh observation and claim.
- Fail closed and locally. Stop the affected account while healthy profiles and unrelated book work continue.
- Prove both layers. Pass cross-profile tests, then verify the boundary in a controlled authenticated pilot.
Account isolation is not glamorous. Nobody puts “we did not publish the right book through the wrong company” in a launch announcement. But in a bulk operation, that non-event is one of the most valuable results the system can produce.