How to Generate a Daily Front Backlog Digest Email for Support Managers

Build a Spojit workflow that lists open Front conversations every morning, groups them by inbox and age, uses an Agent-mode Connector node to summarize and flag the backlog, and emails a prioritized digest to your support-manager distribution list.

What This Integration Does

Support managers usually start the day by manually scanning Front inboxes to see what piled up overnight: which conversations are still unassigned, which have been sitting open for days, and which inbox is carrying the heaviest load. This workflow does that scan for them. Every weekday morning it reads open conversations from Front, organizes them by inbox and by how long they have been waiting, uses an Agent-mode Connector node to summarize the state of the backlog and call out anything aging or unassigned, and sends a clean digest email to the team. The result is one short message that tells managers where to point their attention before the queue gets worse.

The run is driven by a Schedule trigger on a 5-field cron expression in your chosen timezone, so it fires on its own with no human in the loop. Each run pulls a fresh snapshot of open Front conversations, reshapes that list with a Transform node, passes it to a Connector node in Agent mode that returns a structured summary, and ends with a Send Email node that delivers the digest. The workflow holds no state between runs: each morning rebuilds the picture from scratch, so a conversation that was resolved overnight simply drops out of the next digest, and a re-run produces a current snapshot rather than a duplicate of yesterday's.

Prerequisites

A Front connection in Spojit (API token). See the Front connector reference and Setting Up an API Key Connection.
The token needs read access to your inboxes and conversations (so list-inboxes and list-conversations succeed).
The support-manager email addresses you want to send to, added to your org allowlist under Settings → General → Email recipients. See Configuring the Email Allowlist.
An AI model available for the Agent-mode summary step (this run consumes AI credits only on that one node).

Step 1: Start with a Schedule trigger

Add a Trigger node and set its type to Schedule. Enter a 5-field Unix cron expression and an IANA timezone so the digest lands before the team logs on. For 8:00 AM on weekdays in Sydney, use:

0 8 * * 1-5
Australia/Sydney

The Schedule trigger outputs { scheduledAt }, which you can reference later as {{ trigger.scheduledAt }} to stamp the digest with the run time. A single trigger can hold more than one schedule if you want, for example, a second digest after lunch. For the full field reference see Setting Up a Schedule Trigger.

Step 2: List open conversations from Front

Add a Connector node on the Front connector in Direct mode and choose the list-conversations tool. Direct mode keeps this step deterministic and costs no AI credits. Use the q field to filter to open conversations with Front search syntax, for example:

is:open

Front returns a page of conversations along with a pagination token. Each conversation carries a status (such as unassigned, assigned, or archived), an assignee, the owning inbox, a subject, and timestamps. Map the output to a variable such as conversations. If you run several inboxes and want labels for them, add a second Connector node on Front with list-inboxes and store it as inboxes so the Transform step can match inbox identifiers to readable names.

Step 3: Group and age the backlog with a Transform node

Add a Transform node to reshape the raw list into something the summary step can reason over cleanly. Group conversations by inbox, compute how long each has been open from its created or last-updated timestamp, and bucket them by age so aging threads are easy to spot. A useful target shape:

{
  "generatedAt": "{{ trigger.scheduledAt }}",
  "totalOpen": 0,
  "unassignedCount": 0,
  "byInbox": [
    {
      "inbox": "Support",
      "open": 0,
      "unassigned": 0,
      "ageBuckets": { "under24h": 0, "1to3d": 0, "over3d": 0 },
      "oldest": [
        { "subject": "...", "status": "unassigned", "ageHours": 0, "assignee": null }
      ]
    }
  ]
}

Within the Transform you can use the same data utilities available elsewhere in Spojit: treat anything with status equal to unassigned as needing an owner, and derive ageHours by comparing each conversation timestamp to {{ trigger.scheduledAt }}. Keep only the top few oldest threads per inbox in oldest so the payload stays small. See Using Transform Nodes (Structured Mode) for the structured shaping options.

Step 4: Summarize the backlog in Agent mode with a Response Schema

Add a Connector node and switch it to Agent mode. Agent mode runs an AI agent that reads the grouped backlog and produces a written summary flagging aging or unassigned threads. Turn on the Response Schema so the output is reliable structured JSON instead of free prose. Pass the Transform output in your prompt, for example:

Here is this morning's open Front backlog grouped by inbox and age:
{{ grouped }}

Write a short manager-facing digest. Lead with one headline sentence on
overall backlog health. For each inbox, give a one-line status. Then list
the threads that most need attention, prioritising unassigned conversations
and anything open more than 3 days. Keep it factual and concise.

Define a Response Schema such as:

{
  "type": "object",
  "properties": {
    "headline": { "type": "string" },
    "inboxSummaries": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "inbox": { "type": "string" },
          "status": { "type": "string" }
        }
      }
    },
    "priorityThreads": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "subject": { "type": "string" },
          "reason": { "type": "string" },
          "ageHours": { "type": "number" }
        }
      }
    }
  }
}

Store the result in a variable such as digest. For when to reach for Agent mode versus Direct mode, see How to Choose Between Agent Mode and Direct Mode and How to Use Structured Output for Reliable AI Data Extraction.

Step 5: Deliver the digest with a Send Email node

Add a Send Email node. It sends from Spojit's built-in mail service, so no extra connection is needed. Set the fields:

Recipients: your support-manager distribution list, comma-separated, for example support-managers@yourcompany.com. Every address must be on the org allowlist.
Subject: templated, for example Front backlog digest - {{ digest.headline }}.
Body: plain text built from the structured digest variable, for example the headline, then one line per inbox from {{ digest.inboxSummaries }}, then the priority threads from {{ digest.priorityThreads }}.
If sending fails: choose Fail the workflow so a delivery problem is visible in your execution history rather than silently skipped.

Only upstream variables resolve in the body, which is exactly what you have here. For more on this node see Using Send Email Nodes. If you need the digest to come from your own domain rather than the built-in service, swap this for a Connector node on the Resend or SMTP connector using send-email.

Step 6: Save, enable, and let it run on schedule

Save the workflow and enable it. With the Schedule trigger active, Spojit fires the run on its own each morning and the managers receive the digest without anyone touching the app. You can confirm each delivery in the execution history. See Enabling and Disabling Workflows and Monitoring Workflow Executions.

Tips

Front paginates conversations. If a busy account returns more than one page, follow the pagination token from list-conversations with a Loop node and accumulate the results before the Transform step.
Keep the Agent-mode prompt focused on the small, pre-grouped Transform output rather than the raw conversation list. Fewer tokens means a faster, cheaper summary, and the structured shape gives the agent less to misread.
Use the same timezone in the Schedule trigger and in your age calculations so "open more than 3 days" matches what managers see in Front.
Ask Miraxa to scaffold the canvas for you, for example: "Add a Schedule trigger at 8am weekdays, a Front list-conversations node, a Transform that groups by inbox, an Agent-mode summary with a response schema, and a Send Email node," then fine-tune each node in the properties panel.

Common Pitfalls

If recipients are not on the org allowlist, the Send Email node will not deliver. Add every manager address under Settings → General → Email recipients first.
A Front token without read access to a particular inbox silently omits its conversations, making the backlog look smaller than it is. Confirm the token sees every inbox you care about.
Cron is in the trigger's IANA timezone, not the viewer's. 0 8 * * 1-5 in Australia/Sydney is not 8 AM for a manager in another region. Pick the timezone deliberately.
Without a Response Schema, the Agent-mode node can return prose that varies run to run and breaks your email template. Keep the schema on so {{ digest.headline }} and the arrays are always present.

Testing

Before scheduling it, validate on a small scope. Temporarily narrow the q filter in list-conversations to a single inbox, point the Send Email Recipients at your own address, and run the workflow once from the Run button (you can keep the Schedule trigger and trigger a manual test run). Check the execution history to confirm the Transform produced the grouped shape, the Agent-mode node returned valid structured output, and the email arrived reading the way a manager would want. Once the digest looks right, widen the filter back to is:open, set the real distribution list, and enable the schedule.