Email triage workflow template you can fork today

If you want a practical email triage workflow template you can copy into Gmail today, use a 4-tray system built around Act, Wait, Read, and Archive. A lightweight Gmail + Apps Script setup is enough to label, sort, and archive mail on a schedule without adding another inbox tool.⁴⁶

What is this email triage workflow template?

This email triage workflow template is a repeatable Gmail system that moves incoming messages into four action-based trays: Act, Wait, Read, and Archive. The goal is to reduce inbox scanning, separate decisions from administration, and make every message land in one clear next step.⁴¹

Why a 4-tray model instead of a messy inbox?

A 4-tray model works because triage is about decision speed, not inbox purity. Shared inbox tools like Missive already separate handled conversations from open work using states such as Inbox, Archive, Closed, Snoozed, and Trash, which maps cleanly to act-now, wait, read-later, and done-but-searchable.¹

Inbox productivity advice has also shifted away from treating empty inboxes as the only goal. The better pattern is workflow design: templates, unsubscribe rules, batching, and consistent processing rules that keep email manageable over time.²

How does the workflow work in practice?

This workflow sorts incoming email into one of four outcomes based on what you need to do next: act now, wait for something, read later, or archive for reference. In practice, that means every message is handled once, assigned a label, and either left visible for action or moved out of the way.⁴¹

The four trays at a glance

Tray	Meaning	Gmail outcome	Example
Act	Needs a reply or task now	Keep unread, label, optionally star	Client asking for a quote
Wait	You are waiting on someone else	Label and snooze or keep flagged	Vendor promised a revised file
Read	Useful, but not urgent	Label and archive	Industry newsletter or note
Archive	Done and reference-worthy	Archive after labelling	Receipt, confirmation, completed thread

This structure borrows from shared inbox systems that treat archive as done but searchable, not deletion.¹ It also matches the broader workflow-automation trend toward reusable templates that non-developers can fork and customize.⁴

Why build it in Gmail and Apps Script?

Gmail + Apps Script is a strong fit because it gives you native access to Gmail services and scheduled execution without extra infrastructure.⁴⁷ Google’s Apps Script Gmail quickstart shows the platform is designed to call Gmail APIs from a script project, and it supports the normal authorisation flow needed to run automation safely.⁷

Creators are already using Google Sheets and Apps Script to automate email campaigns and follow-up workflows, which is the same pattern you need here: read mail, classify it, log it, and apply the right action.⁶ That makes this template more than a concept; it is a very ordinary Google Workspace automation pattern.

How do you set it up?

You set it up by creating four Gmail labels, adding a time-based Apps Script, and running the script against unread or recent messages in batches. A staged rollout is best practice, because template workflows should be tested before full production use to avoid mislabeling or moving critical mail too early.⁵

What you need

• A Gmail account on Google Workspace or personal Gmail
• Access to Apps Script
• Four labels: Act, Wait, Read, Archive
• A time trigger, such as every 10 or 15 minutes
• Optional: a Google Sheet for logging

Setup steps

1. Create the four Gmail labels.
2. Decide your rules for each tray.
3. Open Apps Script and connect it to Gmail.
4. Paste the script below.
5. Run it once manually and approve permissions.
6. Test on a small batch before enabling the timer.⁵⁷

What does the script look like?

This script scans unread mail, classifies each thread with simple rules, applies the right label, and archives messages that belong in reference storage. It is intentionally plain so you can fork it today and adapt the matching logic to your own inbox.

const LABELS = {
  ACT: 'Act',
  WAIT: 'Wait',
  READ: 'Read',
  ARCHIVE: 'Archive'
};

const MAX_THREADS = 50;

function triageInbox() {
  const labels = getOrCreateLabels_();
  const threads = GmailApp.search('in:inbox is:unread', 0, MAX_THREADS);

  threads.forEach(thread => {
    const message = thread.getMessages().pop();
    const subject = (message.getSubject() || '').toLowerCase();
    const body = (message.getPlainBody() || '').toLowerCase();
    const from = (message.getFrom() || '').toLowerCase();
    const text = `${subject} ${body} ${from}`;

    const tray = classify_(text);

    clearKnownLabels_(thread, labels);

    if (tray === LABELS.ACT) {
      thread.addLabel(labels.ACT);
      thread.star();
    } else if (tray === LABELS.WAIT) {
      thread.addLabel(labels.WAIT);
      thread.markUnread();
    } else if (tray === LABELS.READ) {
      thread.addLabel(labels.READ);
      thread.markRead();
      thread.moveToArchive();
    } else {
      thread.addLabel(labels.ARCHIVE);
      thread.markRead();
      thread.moveToArchive();
    }
  });
}

function classify_(text) {
  const actKeywords = ['urgent', 'asap', 'today', 'call me', 'need your reply', 'deadline'];
  const waitKeywords = ['waiting for', 'pending', 'after you review', 'once approved', 'follow up'];
  const readKeywords = ['newsletter', 'update', 'digest', 'report', 'article', 'read when'];

  if (containsAny_(text, actKeywords)) return LABELS.ACT;
  if (containsAny_(text, waitKeywords)) return LABELS.WAIT;
  if (containsAny_(text, readKeywords)) return LABELS.READ;
  return LABELS.ARCHIVE;
}

function containsAny_(text, words) {
  return words.some(word => text.includes(word));
}

function getOrCreateLabels_() {
  return Object.keys(LABELS).reduce((acc, key) => {
    const name = LABELS[key];
    acc[key] = GmailApp.getUserLabelByName(name) || GmailApp.createLabel(name);
    return acc;
  }, {});
}

function clearKnownLabels_(thread, labels) {
  thread.removeLabel(labels.ACT);
  thread.removeLabel(labels.WAIT);
  thread.removeLabel(labels.READ);
  thread.removeLabel(labels.ARCHIVE);
}

How should you adapt the rules?

You should tune the keyword rules to your own inbox, because the best triage template reflects your actual message patterns. A consultant will see different signals than an operations lead, and a solopreneur will likely want stronger rules for newsletters, scheduling, and vendor follow-ups.⁴²

Good rule examples

• Act: client asks, deadline, payment issue, contract question
• Wait: internal review, external approval, pending response, waiting for assets
• Read: newsletter, update, digest, memo, article
• Archive: receipts, confirmations, FYI messages, completed threads

If you already use shared inbox concepts, the mapping is straightforward: archive for handled and searchable, close or mark done for completed work, and wait for anything that needs someone else to move first.¹

How does this compare with other options?

A Gmail + Apps Script template is usually the lightest viable option, while dedicated automation platforms add convenience and integrations at the cost of another tool layer.⁴ If you already live in Gmail, the simplest system is often the most maintainable.

Option	Best for	Strengths	Trade-offs
Gmail + Apps Script	Solo operators and small teams	Cheap, custom, native to Gmail	Requires light scripting and testing
Zapier	Faster no-code automation	Easy templates, broad integrations	More expensive at scale, less custom control
Airtable-based workflow	Logging and review-heavy processes	Structured records, automation steps	More setup, more moving parts
Shared inbox tool	Team triage	Clear states, collaboration, assignment	Another client to manage

Zapier’s own workflow-automation guidance stresses that these tools are meant to be usable by anyone and that templates are central to the model.⁴ That is useful context, but if your goal is a copy-paste Gmail triage system, Apps Script keeps the logic close to the inbox.

What should you test before going live?

You should test on a small batch first, because staged rollout is safer than bulk automation. Pendo’s guidance on staging templates before full use is directly relevant here: if the logic is wrong, the cost is not technical failure, it is misrouted email.⁵

Practical test plan

• Run the script manually on 10–20 recent unread threads
• Verify each label lands in the right tray
• Check that archived mail is still searchable
• Confirm that urgent mail stays visible
• Watch for false positives in newsletters and vendor threads

That last step matters because inbox automation gets useful only when it behaves predictably. A workflow that saves time but hides important mail is not a productivity system; it is just a faster way to create confusion.

Where does this fit in a broader inbox system?

This template fits best as the first layer of a repeatable inbox process. The point is not to make every email disappear; it is to separate decision-making from storage so that your inbox becomes a processing queue rather than a permanent to-do list.²¹

Frequently asked implementation questions

Can this work without AI?

Yes. The version above uses simple rules rather than model calls, which makes it faster, cheaper, and easier to debug. If you later want AI classification, you can swap the classify_() function for a model-based decision step and keep the same four-tray output.⁴⁶

Do I need Google Sheets?

No. Sheets is useful for logging and audits, and creators already use Google Sheets plus Apps Script to run full email workflows, but the core triage loop can live entirely inside Gmail.⁶

Is archive the same as delete?

No. Archive means handled and still searchable, while delete means removal. That distinction is central to shared inbox systems and should stay central in your triage template too.¹

How often should it run?

Start with every 10 or 15 minutes if your inbox is active, then adjust after you see real volume. Google Apps Script supports time-based triggers, which is what makes scheduled triage practical without extra servers.⁴⁷

Will this replace manual inbox work?

No. It removes repetitive sorting, but you still decide what to reply to, delegate, wait on, or store. The workflow simply makes those decisions visible and repeatable instead of hidden inside one crowded inbox view.²⁴