The daily decision queue for a raise

Why the tracker fails at 9am

The investor spreadsheet is built around the wrong unit. Its unit is the investor: one row per person or fund, with status, stage, notes. But you do not "do" an investor. You do an action: send this reply, request this intro, prep for that call, nudge this thread before it goes cold. The work is a list of actions, and the tracker never produces that list. It makes you derive it, by hand, every morning, from 60 rows of context you have to re-read because you have forgotten which of them is waiting on you.

So the founder defaults to the two worst heuristics available. The first is recency: whatever email is on top of the inbox gets answered, regardless of whether that investor matters. The second is comfort: the founder works the warm, friendly threads and avoids the awkward ones, even though the awkward ones (the partner who went quiet, the term sheet that needs a hard question answered) are usually where the round is decided.

Both heuristics optimize for feeling productive. Neither optimizes for the round. A live round has a small number of moves on any given day that genuinely change the outcome, and they are almost never the ones sitting on top of the inbox.

The decision queue: a score, not a list

A decision queue is a ranked list of next actions, one line per action, sorted by a priority score you compute the same way every morning. The point of scoring it is to take the decision out of your mood and put it into a formula. You stop asking "what do I feel like doing" and start reading "what does the round need first."

Six inputs decide the score. Each is something you already half-know and never write down.

Signal strength. How interested is this investor, based on observed behavior, not vibes? A second meeting requested, a partner looped in, a diligence question asked, a "send me the data room" all rank high. A polite "keep me posted" ranks low. Score the action they took, not how nice the email felt. Use 1 to 5.

Round-stage fit. Where is this investor in your process: new lead, first meeting done, deep in diligence, verbal, or term-sheet stage? Actions on investors close to a decision outrank actions on cold leads, because moving one investor from "verbal" to "signed" is worth more than a new first meeting. Use 1 to 5.

Promised follow-up. Did you say you would send something and not send it? This is the highest-weight input, because a broken promise to an interested investor is the cheapest possible way to kill momentum, and it is entirely your fault. If you owe them anything, the action jumps the queue. Treat it as a yes/no multiplier, not a soft factor.

Decay. How long since the last touch, measured against how long this stage can safely sit? A new lead can wait a week. An investor in active diligence going quiet for five days is an emergency. Decay is not days since contact. It is days since contact relative to the stage's safe interval. The closer to the round, the shorter the fuse.

Warm path. Is there a warm introduction available that you have not used? An action you can take through someone the investor trusts is worth more than the same action sent cold, so the existence of an unused warm path raises the priority of starting that thread now, before the round momentum fades and the introducer's note gets stale.

Investor fit. Does this investor match your stage, check size, sector, and thesis? Low fit caps the score no matter how friendly the thread is. A great relationship with an investor who will never write your check is a time sink dressed as progress.

Combine them like this:

priority =
    (signal_strength × stage_fit × fit_weight)     # base value of the action
  + decay_pressure                                  # how overdue it is for its stage
  + warm_path_bonus                                 # unused warm intro available
  × promise_multiplier                              # ×2 if you owe them something

You do not need real arithmetic precision here. You need a consistent ordering. The formula's job is to make the same situation always sort the same way, so that "the diligence thread that went quiet four days ago and that you owe a metrics doc" always lands above "reply to the cold lead who said keep me posted," every single morning, without you re-litigating it.

A worked queue

Here is one founder's queue on a Tuesday, generated from the six inputs. Notice that the action on top is not the most recent email and not the most pleasant one.

The bad-tracker version of this same morning would have started at row 6, because that email arrived most recently and felt easy to clear. The queue version starts with the doc you owe a fund that is one document away from a yes. Same data. Different question asked of it.

The artifact: build your own decision queue

Two pieces. A schema for each action row, and the priority logic that sorts them.

Action row schema. One row per action, not per investor. An investor with three things owed produces three rows.

action_id
investor / fund
action_type        (reply | send_promised | request_intro | meeting_prep | nudge | first_outreach)
stage              (lead | met | diligence | verbal | term_sheet)
signal_strength    (1–5, based on their last observed behavior)
investor_fit       (high | medium | low)
last_touch_date
stage_fuse_days    (safe gap for this stage: lead 7, met 5, diligence 2, verbal 2)
promise_owed       (yes | no: did you commit to send something?)
warm_path          (none | available_unused | already_used)
priority_score     (computed)

Priority logic, in plain steps. Run this top to bottom; it produces the ordering above.

1. Drop or bottom-rank any action where `investor_fit = low`. Friendly but wrong-fit is not round work.
2. Compute base value: `signal_strength × stage_weight`, where stage_weight is lead 1, met 2, diligence 3, verbal 4, term_sheet 5. Closer to signed counts more.
3. Add decay pressure: if `today − last_touch_date > stage_fuse_days`, add the number of days over the fuse. Overdue diligence climbs fast; an overdue cold lead barely moves.
4. Add a warm-path bonus if `warm_path = available_unused`. An unused warm intro is decaying value; spend it.
5. If `promise_owed = yes`, multiply the whole score by 2. Owing an interested investor is the cheapest way to lose them.
6. Sort descending. Work the top three. Do not look at the rest until those are done.

The "top three" rule matters as much as the score. The queue is not a to-do list you grind through. It is a way to guarantee that the three highest-impact moves happen before the day fills with everything else. Three done well beats forty touched lightly.

The morning workflow

The whole thing should take ten minutes to run and the rest of the block to execute.

First, regenerate the queue from current state: any reply you got overnight changes signal and last-touch dates, so the order shifts. Second, read only the top three and commit to them out loud or in writing. Third, do them before opening Slack, email triage, or anything inbound. Fourth, when a thread advances (they reply, you send the thing, a meeting gets booked), update that row's signal and last-touch so tomorrow's queue is honest. That is the entire loop. The discipline is not in the formula. It is in working the top of the queue instead of the top of the inbox.

One failure mode to name: do not let the queue become a second tracker you maintain for its own sake. If updating it costs more than the decision it saves, you will stop. Keep it to the few fields above. The queue earns its place only if reading it is faster than re-deriving the decision from scratch every morning, which, with 40 open threads, it almost always is.

Where this breaks by hand

The logic is simple. Keeping the inputs current is not. Signal strength changes every time an investor replies. Decay changes every day by definition. Promises owed live in your sent folder, not your tracker. Warm paths live in your contacts and your team's LinkedIn, not in any column you maintain. To score the queue correctly each morning, you would have to reconcile your email, your calendar, your meeting notes, and your investor list by hand, before 9am, every day. Most founders do it for three days and quit, and the queue rots back into a static spreadsheet.

That reconciliation is exactly what a fundraising operating system should do instead of you. The inputs already exist across your sources: replies and promises in email, meetings in your calendar, what was said in your meeting notes, fit and stage in your investor list. RoundOS reads those sources, updates signal, decay, and owed-promises automatically, and produces the ranked decision queue so the first thing you see is the action, not 60 rows you have to re-read. You make the judgment calls. The system does the bookkeeping that the judgment depends on.