The first 2 minutes after graduation

If you are building a pump.fun bot, sooner or later you end up looking at graduation. It is the moment a coin fills its bonding curve and moves to a real pool, and a lot of bots are built around it. It is also one of the fastest, roughest moments in a coin's life.

This post is about what happens in those first couple of minutes, and the practical things that decide whether your bot is early, on time, or the exit liquidity for someone else.

What graduation actually is

On pump.fun, a new coin trades on a bonding curve: a price formula, not a pool. When enough SOL has gone in, the curve completes, and the coin "graduates" to a PumpSwap pool where it trades like any other token.

From a bot's point of view, three things change at once. There is now a pool with real reserves. Lots of people are watching the same event, because graduation is easy to detect. And everyone who bought on the curve now has a clear chance to sell into the new buyers.

Takeaway: graduation is not a calm starting line. It is a crowded doorway.

Big holders do not wait long

Some of the wallets that bought on the curve hold a big share of the supply. When one of them sells hard, the price can fall a long way in one block.

We looked at this on our own recordings. Of the pump.fun graduates from October 10 to 12, 2026, 894 had a big-holder dump by our recorder's size rule in the first 10 minutes. The median time of that dump was 2.2 minutes after graduation.

That is the median, so half came even sooner. If your bot needs a minute to notice the graduation, another minute to decide, and some seconds to land a transaction, it can arrive right as the selling starts.

Takeaway: your whole plan, entry and exit, may have to fit inside a couple of minutes. Design for that from the start, not as a tweak later.

Why reaction time matters more here than anywhere

On a slow chart, a few seconds of delay costs you a little. Right after graduation, a few seconds can be the difference between buying before a dump and buying into one, or between selling at a stop and selling after the pool has been drained.

There are two separate delays, and it helps to measure them separately:

1. Seeing: how long between the graduation landing on chain and your bot knowing about it.
2. Acting: how long between your bot deciding and its transaction landing in a block.

Takeaway: "my bot is fast" is not a measurement. Two numbers are.

Websocket vs polling

Many first bots poll: every few seconds, ask an API "anything new?". It is easy to write, and AI tools often suggest it. The cost is that, on average, you see every event half a polling interval late, plus the request time.

A websocket (or another streaming subscription) pushes events to you as they happen. It is a bit more work: you need to handle disconnects, reconnect, and notice gaps. But for anything that happens in the first two minutes, polling every few seconds throws away a real slice of the window.

# polling: you learn about an event up to POLL_SECONDS late
while True:
    for ev in api.get_new_graduations():
        handle(ev)
    time.sleep(POLL_SECONDS)

# streaming: events arrive when they happen
async for ev in ws.subscribe("graduations"):
    handle(ev)

Takeaway: if your strategy lives in the first minutes, stream. Then log every disconnect, because a silent gap looks exactly like a quiet market.

Measure your own latency

You do not have to guess how slow your bot is. Log three timestamps for every trade:

• the block time of the event you reacted to (from the chain)
• the time your bot received it (your clock)
• the block time your transaction landed in (from the chain)

seen_delay   = received_at - event_block_time
landed_delay = tx_block_time - received_at

Run it for a day, then look at the median and the slow tail, not the best case. Keep your server clock synced, or the numbers will lie to you.

Takeaway: once you know your real delays, put them into your backtest. If your bot really lands six seconds after the signal, test entries at six seconds, not at zero.

Then test the window honestly

Knowing the window is short is only useful if your tests respect it. A backtest that fills at the graduation price, or checks prices every 30 seconds, will miss most of what happens in the first two minutes. You need every trade, block by block, for each coin, including the ugly ones.

The hopeful part: short windows are exactly where careful, honest testing can find things that lazier bots miss. Better rules might exist here. The way to find out is to replay them on what actually happened, with your real delay built in.

If you want to look at those first minutes yourself, the free one-coin file has one graduate's 30 minutes, trade by trade, and a full day ($10) has every graduate's.