A Growth Timeline: Every Budget Change Auto-Logged as an Event
Summary
We auto-log every optimization action (budget, bid, status, keyword, negative, ad push) as a timestamped event with entity, field, old and new value — and once lost 3 events to a 32-bit integer overflow before widening to 64 bits.
Quick answer
Define an event schema (entity, field, old value, new value, timestamp), instrument every write operation so budgets, bids, statuses, keywords, negatives and ad pushes auto-log, and confirm key operations with an explicit recorded message. Use a 64-bit event ID — we lost three events to a 32-bit overflow — and pair the timeline with daily snapshots for causal review.
Here is a question we could not answer for years: what exactly did we do to this account last month? Budgets changed. Bids changed. Keywords paused. Negatives added. Each change happened for a reason at the time — and yet when a metric moved, we had no reliable record of the operation sequence behind it.
The problem: operations were invisible
When multiple people optimize an account, the changes live in scattered places: the Ads UI, spreadsheets, chat messages, memory. Asking what we changed and when produced a shrug. Without a record, cause and effect is guesswork — you cannot attribute a result to an action you cannot prove happened.
The solution: an event timeline
We built a timeline where every optimization action becomes a timestamped growth event. Budget changes, bid changes, status flips, keyword edits, negative additions, ad pushes — each is recorded with the entity, the field, and the old value and new value. And for money-moving or structure-changing operations, the user gets an explicit confirmation after execution: recorded to the timeline.
The design has two hard-won details. First, the event ID type must be large enough. We once lost three events silently to a 32-bit integer overflow before widening the column to 64 bits — a subtle bug that only shows up when you need the record most. Second, every event carries a snapshot of the entity's context, so a single event is never read in isolation.
What the timeline gives you
Every operation becomes replayable, auditable and attributable. When a conversion metric jumps or drops, we can walk the timeline: this is when the budget changed, this is when the keyword was paused, this is what happened after. Combined with daily state snapshots, the timeline is the input for causal reasoning and experiment evaluation — the what-changed-and-what-resulted question finally has an answer with evidence. It also turns a common team argument into a lookup: instead of debating whether we touched a campaign last week, we open the timeline and read the exact sequence.
The reusable checklist
- Define event types and fields. Entity, field, old value, new value, timestamp.
- Instrument every write operation. Budgets, bids, status, keywords, negatives, ads.
- Confirm explicitly for key operations. Money and structure changes get a logged confirmation.
- Pair the timeline with daily snapshots. Events say what changed; snapshots say what resulted.
This timeline is the event backbone of our attribution & growth engine — every optimization automatically becomes part of the record.
Frequently asked questions
Why did a 32-bit event ID lose data?
When the ID counter exceeded the 32-bit range, writes failed silently instead of erroring visibly — three events vanished with no alert. Widening the column to 64 bits removed the ceiling; the lesson is to size identifiers for the long run, because overflow fails quietly.
What exactly should an event record?
At minimum the entity (which account, campaign or keyword), the field changed, the old value and the new value, and the timestamp. Together these make the record self-explanatory: you can replay what happened without asking anyone.
How do events and snapshots work together?
Events answer what changed and when; snapshots answer what resulted. A timeline event explains why a metric moved the way it did, while the daily snapshot confirms the effect on the metric — the pairing turns observation into causal analysis.