What does the application's own session store show during a suspected flood that the edge access log cannot?
answer
- arrivals versus arrivals that went somewhere
- did it come back for a second thing
- bounce rate is not the tell
- a session proves acceptance, not a person
- the store you are reading is also the victim
basics
~20 sWhether arrivals ever became sessions with a forward path — a second request, state returned, something completed. The edge sees arrivals; only the application sees whether anything went anywhere. Traffic sent to consume capacity tends only ever to arrive.
solid answer
~50 sThe edge log records that a request arrived and what was served. The session store records whether the arrival went anywhere afterwards: did the client come back for a second path, return the state it was handed, progress through a flow, complete anything. A real launch crowd has plenty of one-page visitors, but they still accepted and returned a cookie, fetched the page's subresources, and a measurable slice of them finished something. A flood dressed as growth is usually a population of arrivals that never return. The caution is that bounce rate alone is not the discriminator — sold-out pages produce huge genuine bounce cohorts, and your own client retrying produces repeated first-page arrivals from users with valid history. The price is that this evidence is slower to reach you than the edge view, it needs someone with application access on the bridge, and the session store is itself a resource the flood is filling, so the measurement degrades exactly when you need it.
go deeper
Know the difference between a request arriving and a visitor doing something afterwards, and that the edge log only ever shows the first of those.
Explain the forward-path signals concretely — second path requested, state issued and returned, subresources fetched, a flow completed — and why each is harder to fake than an arrival.
Demonstrate that you check whether an empty forward path means nobody is walking it or that you broke it, and that you know the store you are querying is itself under the load.
Own the design consequence: the correlation key that lets an edge record be matched to a session has to exist and be retained before the incident, or this evidence is unavailable on the day.
## Two vantages, two different facts An edge access log answers: *a request arrived, here is what I served, here is how long it took*. That is a per-arrival record. The application's session store answers a different question entirely: *did this arrival turn into anything?* Sessions carry forward — a state token issued and then presented again, a cart, a step counter in a signup flow, a search followed by a result click. The forward path is the part that is expensive for an adversary to fake and cheap for a real person to produce, because real people are trying to do something. So the shape signals, roughly in increasing strength: 1. **Depth.** Did the client request a second distinct path? 2. **State carried forward.** Was a session token issued and then presented on a later request? Did the client fetch the page's own subresources, which a browser does automatically and a bare request generator often does not? 3. **Completion.** Did any measurable fraction reach the thing the launch existed for — a purchase, a signup, a queue place? A flood shaped like growth typically shows a large arrival count with a forward path that is flat at zero. Arrivals that only ever arrive. ## The wrong answer this question is aimed at The competent-sounding answer is *bounce rate is 97 percent, therefore attack*. It is wrong twice. - **A real launch produces an enormous single-page cohort.** People arrive, see a countdown, see sold out, see a price, and leave. On a launch morning the honest bounce fraction can be terrible and the traffic entirely genuine. If you key the decision on the bounce fraction you will block your own launch. - **Your own client retrying looks like repeated first-page arrivals.** If a backend is slow and the mobile app re-issues the call, you get many arrivals for one path from clients that are unquestionably real. Those clients typically have valid prior sessions and history, which is exactly what a flood does not have. Blocking them turns a degraded service into an outage for the people you already had. The correction is that the discriminator is not the *fraction* that bounced but whether the cohort ever behaved like a client at all: did it accept and return state, did it pull the subresources, does it have any prior relationship with you. A genuine bouncer still did all of the first two. ## The direction of the claim Be precise about what a session record proves. A created session proves that a request was accepted and a token was issued — it does not prove a human was present, and an adversary willing to spend a little more can create sessions. Equally, the absence of completions proves nothing on its own about intent: if the launch page is failing for capacity reasons, genuine users cannot complete either, and you will read your own outage as evidence of an attack. Always check whether the forward path is empty because nobody is walking it or because it is broken. ## What this costs you This is the leaf's real tension, and an interviewer will look for it: | Cost | Why it bites on launch day | | --- | --- | | Latency of evidence | The application view lags the edge view. Sessions have to be created and then not followed up, which takes minutes you may not have before the fixed launch time. | | Access | Someone with production application or database access has to be on the bridge to read it, and on launch morning that person is usually busy shipping. | | Self-degradation | The session store is a resource the flood is filling. Under enough load it slows, evicts, or starts rejecting — so the measurement gets worse precisely as the situation gets worse, and low completion counts may reflect your own store failing rather than the traffic's nature. | | Sampling and privacy | If the store or its analytics are sampled, aggregated hourly, or stripped of the join key that would let you match a session to an edge record, the correlation you need may be impossible in the window you have. | ## Using it together with the edge view The two vantages are complementary and each covers the other's blind spot. The edge tells you the sources spread broadly but present very few distinct client fingerprints; the application tells you those arrivals never came back for a second thing. Either alone has an innocent explanation — your own mobile client explains the first, a sold-out page explains the second. Together, they rarely do, and that conjunction is what a launch-day owner should be looking for rather than a bigger number on a graph.
- Completions are near zero. Why is that not immediately proof of a flood?Because your own service may be failing. If the launch path is timing out or the checkout is erroring under load, genuine users cannot complete either, and you would be reading your own outage as evidence about the sender. Check error rates and latency on the completion path before treating a flat completion line as a verdict about who is arriving.
- How do you tell a self-inflicted retry storm from a flood on the session evidence?Retries come from clients with history: valid prior sessions, recognised state, a plausible relationship with you, and the volume tracks your own error rate rather than an external event. A flood's arrivals typically have no prior relationship and never return state. If arrivals rise as your errors rise and fall when you fix the backend, you were fighting yourself.
- The session store is degrading under the load. What do you rely on instead?The cheaper structural proxies at the edge that do not need the store: whether clients fetched the page's own subresources, whether the same client presented a cookie you issued on a later request, and the fingerprint-versus-source pairing. They are weaker individually, but they survive when the stateful tier is the thing being crushed.
The door counter records everyone who walked in. The till records who reached a checkout. On a day when the shop may be full of people who have no intention of buying, only the second number tells you which crowd you have.
saying these in an interview costs you the question
- Uses bounce rate alone as the attack verdict
- Assumes a created session means a human was present
- Reads zero completions without checking the path still works
- Blocks retrying clients that have valid prior sessions
- Assumes the session store stays readable under the load