Attio just shipped the ARRAYFORMULA of the CRM. Here's what you can delete.

If you've ever used ARRAYFORMULA in Google Sheets, you remember the moment it clicked.

One formula, and suddenly the whole column just works. You stopped writing a calculation and started defining a rule. It ran on every row, forever, and recalculated on its own. You never touched it again.

Attio's new formula attributes are that same moment, for the CRM.

Write the logic once, and it computes across every record in the object. It's not a cell. It's a rule that lives inside your data model, recalculating itself the second the underlying data changes. And because it's a real attribute, the output flows into everything else: you can filter and group views by it, use it as a metric in reports, trigger workflows off it, and pull it into sequences.

That alone would be a solid release. But the part that actually changes how you build in Attio is quieter, and it's the reason half of your automations are about to become dead weight.

Formulas that read history

Every CRM knows what your data is right now. Almost none of them know what it was.

That gap is where a huge amount of RevOps work has always lived. How long has this deal actually been sitting in Negotiation? What stage was this account in 90 days ago? Did this opportunity ever pass through a stage before it died? What was the seat count before the last change?

Until now, answering those questions inside Attio meant building machinery. You'd stamp a timestamp on every stage change with a workflow, store it in a hidden attribute, then compute the delta somewhere else. Every field you wanted to track over time was its own little Rube Goldberg setup of triggers and stored values.

Attio's formula attributes now include attribute history functions that read the past directly:

• timeSpentIn measures how long an attribute sat at a given value, like a deal stage.

• hasBeenIn checks whether an attribute ever passed through a given value.

• valueAt returns what an attribute was on a specific date.

• previousValue returns what it was before the last change.

• valueSetAt pinpoints when it changed.

Read those again with your own setup in mind. These are the exact questions you used to answer by exporting to a warehouse, modeling them in dbt, and waiting three days for an analyst to hand you a number half the team didn't trust anyway.

Now it's a field. It sits on the record. It's correct. It updates itself.

The workflows you can now delete

This is where the release stops being interesting and starts being a real change to your Attio setup. A large share of the automations most teams have built exist purely to compute, stamp, and refresh values. Formula attributes make a lot of that redundant.

Concretely, here's what tends to disappear:

Timestamp-stamping workflows. The classic pattern: a workflow fires on stage change, writes the current date into a hidden "entered stage X on" field, and a second workflow computes days-in-stage from it. timeSpentIn replaces the entire chain. No trigger, no stored field, no second calculation.

"Days since" and aging fields. Any field that tracks how long something has been in a state, and the scheduled automations that recompute it, collapse into a single reactive formula. Nothing to re-run on a schedule, because formulas recalculate on their own within seconds of the data changing.

Snapshot and history-tracking automations. Setups that periodically copy a value into a "previous value" field so you can compare later are now handled by previousValue and valueAt natively. You stop maintaining your own shadow history.

Threshold and scoring plumbing. Weighted pipeline, decay scoring, health scores. These were often multi-step workflows chaining stored intermediate values. Because formulas are composable (a formula can reference another formula), you set your stage probabilities once and reuse them everywhere: weighted pipeline, a report, a scoring model. Fewer moving parts, one source of truth.

Calculation blocks inside workflows. A lot of the transform-and-aggregate logic people wired into legacy calculation blocks can move up to the attribute layer, where it's visible on the record instead of buried inside a workflow step nobody remembers building.

There's a second-order effect that matters for anyone on a usage-based plan: fewer workflow runs means fewer credits burned. Every scheduled recompute and stamp-on-change automation you retire is recurring consumption you stop paying for. Formula recalculation isn't a workflow run.

Why this is a genuine architecture shift, not just a feature

The reason this matters beyond convenience comes down to three properties Attio built into formulas.

They're deterministic: the same inputs give the same answer every time, which is exactly what you want for a number you'll forecast on or defend in a board meeting. This is the deliberate counterweight to AI attributes. Agents are the right tool when "plausible" is good enough (research an account, triage a lead, flag a signal). Formulas are the right tool when the answer has to be exactly right. A healthy Attio setup now uses both, deliberately, for different jobs.

They're composable: formulas stack and reference each other, so your logic stops being duplicated across five workflows and lives in one place.

They're reactive: when the underlying data changes, the formula recalculates itself within seconds, and it doesn't slow down as your workspace grows.

Put together, that's the difference between a CRM you look at and a CRM that computes. Historical questions that used to leave the system and come back as stale exports now live on the record, feed your views, and trigger your motion in real time.

What to do this week

If you run Attio seriously, the practical move is an audit:

1. List every workflow whose only job is to stamp a date, compute a delta, snapshot a value, or refresh a score.

2. Check which of them collapse into timeSpentIn, hasBeenIn, valueAt, previousValue, or valueSetAt.

3. Rebuild those as formula attributes, confirm the preview matches, and retire the workflows.

4. Count the credits you just stopped spending.

Most setups we've looked at come out meaningfully lighter: fewer automations, fewer hidden fields, one source of truth for each computed value, and a lower monthly run count.

Formula attributes are available on Pro and Enterprise plans. Admins and members with full access to the relevant object or list can create them.

At Novlini we're already rebuilding client setups around this. If you want to know how many of your workflows formula attributes can replace, and how many credits that frees up, we run a free Attio discovery to map it. Reach out and we'll take a look at your setup.