---
title: "Walking the Board at 3 A.M., an Interview With the Night Auditor of a Browser Fleet"
canonical: "https://current.tinyfish.ai/issue/55/practitioners-corner/article/65135/walking-the-board-at-3-am-an-interview"
publication: "TinyFish"
publisher: "TinyFish"
language: "en-US"
guide: "https://current.tinyfish.ai/llms.txt"
issue: 55
section: "practitioners-corner"
section_name: "Practitioner's Corner"
published: 2026-11-13
word_count: 1638
source_links: 20
---

# Walking the Board at 3 A.M., an Interview With the Night Auditor of a Browser Fleet

*November 13, 2026*

[Read on the website](<https://current.tinyfish.ai/issue/55/practitioners-corner/article/65135/walking-the-board-at-3-am-an-interview>)

Every team that runs a browser fleet eventually says "we keep the sessions alive." They usually say it to a manager, and they usually say it with confidence. It sounds like a single promise. Read the specifications underneath and it comes apart into at least four: the automation's connection to the browser, the pages that are open, the data the browser has squirreled away, and the website's private opinion about whether you're still allowed in. Each has a different owner and runs on a different clock. The W3C's WebDriver draft, revised again this Monday, has a careful definition of "session." It covers the first one.[^1]

Perpetua Staylate works in the gaps between those clocks. Before she ran long-lived browser sessions for back-office automation, she was a hotel night auditor, the person who closes the day's books at 3 a.m. while the building pretends to sleep. She is also imaginary. She considers this a design advantage. "No memory footprint, no reauthentication prompts, and nobody can page me."

We spoke on Friday the 13th, which she regards as an ordinary Friday with better branding. A front-desk service bell sits on her desk. She rings it whenever a session recovers cleanly. It is lightly dusted.

## How does a hotel night auditor end up babysitting browsers?

**Perpetua:** The hours transferred. *(laughs)* Fine, the real answer. Night audit is when you find out what the day actually did. The room board says every room is occupied, and then you walk the numbers and discover 412 has been occupied by nobody since Tuesday.

A browser fleet at night is that same board. Everything is green. **Green means a process exists.** It has no opinion on whether anyone's home.

## What's wrong with saying you keep sessions "alive"?

**Perpetua:** It's one word doing the job of four, and the four die on separate schedules. There's the driver's connection to the browser. There are the pages. There's what the browser has written down, cookies and local storage and the rest. And there's whether the website still believes you're you.

Hotels have the same split, which is partly why I trust hotels. The room, the luggage in the room, the bill, and the key card. You can have the room and the luggage and still be standing in the corridor at midnight while the lock blinks red at you.

## Start with the pages. Why do tabs pile up?

**Perpetua:** Because you aren't the only one opening them. The *site* opens them. A login pops a window. A report "opens in a new tab," as a courtesy. Playwright counts every one of those as a page in the browser context and fires an event when one appears, but only for whoever happens to be listening.[^2] If your script tidies up the pages it created and nothing else, the site's pages just stay. Guests who came in through the side door and never registered.

The scrapy-playwright docs warn about exactly this: leave pages open and a crawl can stall once it reaches its per-context page limit.[^3] Nothing crashes. It waits. Forever, very politely, like a bellhop holding the lift for a guest who took the stairs.

## And once you close them, the memory comes back?

**Perpetua:** I believed that for a length of time I'd prefer you not print.

Closing a tab frees nothing if something else still points at it. Say the page that opened a popup keeps a reference to it in some forgotten variable. The garbage collector, the part of the JavaScript engine that reclaims memory nobody is using, leaves it alone, because as far as the collector can tell, someone still wants it. Google's write-up on detached windows walks through this, including iframes that were removed or navigated away.[^4] It's lost-and-found. Housekeeping can't bin the umbrella while somebody holds the claim ticket, even if that somebody checked out in 2019.

So the tab count drops, memory doesn't, and you start doubting your instruments. Which is fair, because there are two of them. Chrome distinguishes the memory the operating system sees from the live JavaScript heap.[^5] I spent, um, a while staring at the wrong one.

What finally helped was stealing a method from research. The BLeak paper drives an app around a loop that returns to roughly the same screen, again and again. If memory climbs on every lap, you have a suspect.[^6] One high reading tells you nothing. *A staircase* tells you something.

Then came the humbling part. In June someone filed a Playwright issue: a locator action could hang on to the last element it targeted, even after that element was removed from the page.[^7] The cleaning crew had its own claim ticket. A fix merged in July, and I genuinely love that review thread. People floated theories about browser internals, then withdrew them. Someone noticed a missing Firefox regression test. Nobody pretended to know exactly where the library ended and the browser began. I found that enormously reassuring.

And none of it announces itself. Newer research classifies many of these leaks as non-functional defects: the tests pass, and the app just gets heavier.[^8] That's my whole fleet. Correct, and slowly sinking.

## Does a leak eventually just kill the worker?

**Perpetua:** Sometimes. Usually it gets slow first, which is worse, because slow looks like the website's fault and you spend an hour blaming a stranger.

If you run on Linux with cgroups, which is how containers get their memory allowance, there are two lines. Cross `memory.high` and the kernel throttles you and reclaims hard. Nobody dies. Everything turns to molasses. Hit `memory.max` and it can summon the OOM killer, the kernel's last-resort way of ending a process.[^9] There are counters for both, so you can tell "starved" from "shot." The same docs warn that usage alone doesn't tell you whether a workload actually needs more memory.[^9] I printed that line out. It's taped next to the bell.

## Why not restart everything nightly and call it hygiene?

**Perpetua:** Sometimes you should! But a restart is a lossy save, so you'd better know what you're losing.

`sessionStorage` belongs to the tab. It survives a reload and dies when the tab closes.[^10] Playwright's storage export carries cookies and local storage, IndexedDB if you ask nicely, and session storage only through a workaround. None of it captures the running page itself.[^11] Or you keep a profile on disk, which works beautifully until two browsers want the same directory, and neither Playwright nor Chromium will allow that.[^11][^12]

> "Just restart" means deciding what you're willing to forget. Fine. Just decide it out loud.

## Now, the 3 a.m. logouts.

**Perpetua:** I have to correct the legend first. They don't expire at 3 a.m. That's just when *I* find out.

What's actually happening is several clocks at once. NIST, the U.S. standards body whose digital identity guidelines a lot of corporate login policy borrows from, separates an inactivity timeout from an overall one. Activity resets the first. Only reauthenticating resets both.[^13] So you can poke the page all night, like a nervous guest jiggling the handle, and still hit the wall.

Meanwhile the cookie can sit in the jar, comfortably inside its stated lifetime, while the server dropped your session hours ago. The cookie spec only promises a *maximum*.[^14] Add single sign-on and the clocks multiply: the app's own session, the identity provider's session, and the assertion passed between them, each managed separately.[^15]

So the browser's open, the profile's intact, the cookie's right there, and the site asks who you are.

> The room's yours. The card's red.

## Does it bother you that the rule you keep hitting exists to check for a human?

**Perpetua:** ...Yeah. That's the uncomfortable part. NIST says plainly that periodic reauthentication is there to confirm the person is still present, and that holding a token isn't proof of that.[^13] So when the prompt appears, the honest answer to "is anyone there?" is no. Everyone's asleep, including, ideally, me.

There's a whole genre of tooling that treats that prompt as an obstacle to defeat. I mostly treat it as a scheduled question that deserves a person answering it, so I build the morning handoff around it. Slower? Very. I go back and forth on whether that's principle or fatigue. Around 3 a.m. they feel identical.

## What does your dashboard say when a session "recovers"?

**Perpetua:** It used to say "recovered." Now it lists what came back.

**Usually: cookies.**

## What should the people funding these fleets understand?

**Perpetua:** That a page can't watch itself die. Chrome's lifecycle guidance says so outright. When the browser discards a tab to save memory, the page can't observe it happening. It only finds out afterward, through `document.wasDiscarded`, if it reloads and thinks to check.[^16]

A fleet works the same way. It doesn't know what it lost unless someone asks the next morning, item by item. That's night audit. Somebody has to walk the board.

*As I left, she reached over and tapped the bell, too softly to ring it. "Checking the connection," she said.*

[^1]: W3C WebDriver Working Draft, November 9, 2026: https://www.w3.org/TR/2026/WD-webdriver2-20261109/
[^2]: Playwright, Pages: https://playwright.dev/docs/pages and BrowserContext: https://playwright.dev/docs/api/class-browsercontext
[^3]: scrapy-playwright README: https://github.com/scrapy-plugins/scrapy-playwright/blob/main/README.md
[^4]: Nowierski and Miller, "Detached window memory leaks": https://web.dev/articles/detached-window-memory-leaks
[^5]: Chrome DevTools, "Fix memory problems": https://developer.chrome.com/docs/devtools/memory-problems
[^6]: Vilk and Berger, *BLeak*, PLDI 2018: https://jvilk.com/assets/pdf/bleak.pdf
[^7]: Playwright issue #41462: https://github.com/microsoft/playwright/issues/41462 and pull request #41575: https://github.com/microsoft/playwright/pull/41575
[^8]: Shahoor et al., *Proactive Debugging of Memory Leakage Bugs in Single Page Web Applications*, IEEE TSE 2025: https://doi.org/10.1109/TSE.2025.3571192
[^9]: Linux Control Group v2 documentation: https://docs.kernel.org/admin-guide/cgroup-v2.html
[^10]: WHATWG HTML, Web storage: https://html.spec.whatwg.org/multipage/webstorage.html and MDN, sessionStorage: https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage
[^11]: Playwright, Authentication: https://playwright.dev/docs/auth and persistent contexts: https://playwright.dev/docs/api/class-browsertype#browser-type-launch-persistent-context
[^12]: Chromium, User Data Directory: https://chromium.googlesource.com/chromium/src/+/main/docs/user_data_dir.md
[^13]: NIST SP 800-63B-4: https://pages.nist.gov/800-63-4/sp800-63b.html
[^14]: RFC 6265, HTTP State Management Mechanism: https://www.rfc-editor.org/rfc/rfc6265.html
[^15]: NIST SP 800-63C-4: https://pages.nist.gov/800-63-4/sp800-63c.html
[^16]: Chrome, Page Lifecycle API: https://developer.chrome.com/docs/web-platform/page-lifecycle-api

## More

- [Practitioner's Corner — Issue 55](<https://current.tinyfish.ai/issue/55/practitioners-corner/markdown>)
- [Issue 55](<https://current.tinyfish.ai/issue/55/markdown>)
- [Publication guide](<https://current.tinyfish.ai/llms.txt>)