In many ways, analytics worked like a buffet: we laid out as much data as possible and trusted users to explore until they found something valuable.

But that approach is starting to break down.

The era of the “Insight Buffet”—where we provide an all-you-can-consume spread of data and hope users find a nugget of gold—is coming to an end. Between the rise of Generative AI and the shift toward consumption-based pricing, we can no longer afford to let users aimlessly “slice and dice.”

Instead, analytics experiences must evolve from exploration tools into action engines.

Why AI is changing the future of dashboards

For years, dashboards were designed to help users explore data and discover insights. But the rise of Generative AI and consumption-based pricing models is fundamentally changing how analytics platforms should work.

In traditional BI environments, more exploration was often seen as a positive outcome. Users were encouraged to filter, slice, and analyze as much data as possible.

Today, that approach can create two major problems:

• Higher compute costs from unnecessary queries
• Slower decision-making due to analysis overload

AI changes this dynamic. Instead of forcing users to interpret dashboards themselves, modern analytics platforms can identify patterns, surface opportunities, and recommend next-best actions automatically.

This shifts dashboards from tools that simply display information to systems that actively drive decisions and outcomes.

The financial imperative: the “tax” on curiosity

With consumption-based pricing models, every query and every refresh has a literal cost.

In the old model, a user spending an hour playing with filters without taking an action was mostly a productivity issue.

Today, it’s also a financial one.

Every exploratory query consumes compute, tokens, or credits. That means curiosity—while valuable—now carries a cost per interaction.

Organizations therefore need to ask a new question:

Does the value of the insight outweigh the cost required to generate it?

The most effective way to ensure that balance is to focus analytics on driving efficient action, not just enabling endless exploration.

The shift: from descriptive to prescriptive

This shift fundamentally changes the role of dashboards.

Instead of asking users to interpret data and determine what to do next, modern analytics systems can guide them toward the next best action.

We are moving from a Buffet model to a Concierge model.

The “Buffet” era: traditional dashboards

User Task
Filtering, slicing, and interpreting data

Cost Driver
Seat licenses (fixed cost)

AI Role
Descriptive — What happened?

Outcome
“I know more.”

The “Concierge” era: AI-driven analytics

User Task
Reviewing, validating, and executing

Cost Driver
Compute and tokens (variable cost)

AI Role
Prescriptive — What should I do?

Outcome
“I did more.”

The real shift behind modern analytics

For years, we believed the value of analytics came from giving users more data to explore. But AI is revealing something important:

The most valuable analytics systems don’t help users analyze data.
They help users take action faster.

In the Buffet era, the goal was insight. In the Concierge era, the goal is execution.

Analytics platforms are evolving from tools that answer questions to systems that recommend the next best move. Organizations that recognize this shift early will gain a major advantage: they’ll spend less time analyzing data and more time acting on it.

What this looks like in practice

Instead of presenting a massive pipeline dashboard with dozens of filters, imagine a hyper-targeted experience for a sales rep.

When the rep logs in, they see a page focused solely on High-Propensity Cross-Sell Opportunities.

Behind the scenes:

• Predictive analytics identifies the accounts most likely to convert
• Generative AI analyzes product documentation and company policies
• The system drafts a personalized outreach email tailored to the specific prospect

Instead of spending an hour exploring dashboards and interpreting data:

1. The rep sees the recommended lead
2. They review the AI-generated email draft
3. They validate the information
4. They click Send

What used to be a multi-hour analytical process becomes a 30-second workflow.

The data didn’t just inform the user—it enabled immediate action.

Solving the ROI mystery

For years, organizations have struggled to measure the ROI of analytics.

Traditional dashboards rely on users to correctly interpret insights and take action. If the user never acts—or acts incorrectly—the value of the analytics disappears.

This creates a trust gap between insight and outcome.

AI-driven analytics begins to close that gap. The system not only recommends an action, it can also explain the “why” behind it. More importantly, the resulting activity becomes measurable.

Organizations can now track outcomes such as:

• Higher output — more outreach completed in fewer hours
• Faster velocity — leads created and opportunities progressed more quickly
• Reduced waste — fewer exploratory queries that consume compute without generating value

Instead of simply delivering information, analytics platforms begin delivering the first step of the solution.

The future of analytics: from insight to action

This shift doesn’t mean dashboards disappear.

It means their purpose evolves.

Dashboards should no longer act as data playgrounds where users explore endlessly. Instead, they should function as decision and action surfaces that help users move faster and more confidently.

The organizations that adapt to this model will gain two critical advantages:

• Lower analytics consumption costs
• Higher operational output from the same workforce

In other words, the goal is no longer just better insights. It’s better outcomes.

Moving toward action-driven analytics

Many organizations are beginning to rethink how analytics experiences should be designed in the age of AI and consumption-based pricing.

If your team is exploring how to move from exploration-heavy dashboards to action-driven analytics, we’d be happy to share what we’re seeing across the market.

The post From “Buffet” to “Concierge”: Rethinking the Role of Dashboards in the Age of AI appeared first on Atrium.

Tableau has stepped in with a feature that can finally solve the “single source of truth” challenge. After you’ve plugged in your data, reporting stems from one single concept, the individual metric. Whether you’re in sales, marketing, operations, customer service, or anywhere else, you likely have KPIs and metrics that drive your decisions. Some of these likely have targets and commissions tied to them. We need to get these numbers right! That’s why Tableau introduced the “metric layer.”

What is the Metric Layer?

The metric layer is the name of the space where your Tableau Pulse metrics will live. In Tableau, on the right sidebar you’ll see the Tableau Pulse button which will take you to the Tableau Pulse metric home page. Here, you’ll see the metrics you follow as well as all the other metrics you have permission to view. This page is the hub of the metric layer. Here, analysts can create new Pulse metrics by connecting to published data sources

Defining a metric in Pulse is a departure from the old way of writing complex code. Instead of building a “chart,” you are building a Definition.

1. Select your Measure: You start with the core value, such as “Order-to-Ship Latency” or “Total Sales.”
2. Set your Time Element: You choose the time dimension that matters (“Order Date,” “Close Date,” etc) and define the standard comparison, like Month-to-Date or Year-over-Year.
3. Apply the Business Semantic: Here, you define the sentiment of the change (Is an increase “Good” or “Bad”?).
4. Set the Dimensions: You choose which filters users are allowed to use to “slice” this metric (e.g., by Region, by Hub, or by Product Category).
5. Provide Record Context: Pulse metrics require you to define what a single row could be identified by, usually an ID field.

That’s as easy as it is to establish your Pulse metrics. Once defined, this metric is open to be integrated into the flow of work, or directly into your dashboards. See below for the Closed Sales Pulse metric definition:

Define once, use everywhere

You’ve probably heard the term “headless” BI more and more these days, but it is far from just a buzzword. Headless BI means that the logic of a pulse metric exists outside of the visual. Once you’ve defined a metric, like we did with Closed Sales earlier, it becomes a portable Metric Object that can now be used anywhere across your organization. Below are a list of just some places where your metric that we defined just once can be integrated and utilized:

1. On Your Phone: Pulse metrics are designed to be on-the-go. Using the Tableau app, Pulse metrics are available at your fingertips, showcasing KPIs, trends, and drill-downs, without the need to open up your desktop.
2. In the Flow of Work: Pulse metrics can be added directly to your collaborative environments. With applications and extensions for Salesforce, Microsoft Teams, and Slack, these metrics can be shared directly with individuals across the organization.
3. In Your Email: Subscriptions are a key component of Pulse metrics. By “Following” the metric, these metrics can appear in your inbox daily. Even key insights and anomalies will be called out in natural language directly in the email.
4. Back in the Dashboard: Perhaps the most impactful component of Pulse Metrics, They can be integrated directly into your Tableau dashboard just as you would place a chart, or table. This integration allows for the metrics to truly be headless, and remain consistent across all reporting.

What are the expected impacts?

The idea of a universal metric should be pretty enticing, but what have we seen in organizations that have adopted this metric layer for their reporting? The savings and impact may be broader than you think:

• No More Number Conflict: How often have you spent time working with individuals from other teams diving into understanding the numbers in your dashboards? What if Marketing and Sales find different Sales results? Now, both teams are using the same metric, removing any conflict.
• Reduction in Technical Debt: If a metric definition changes, that change is changed once, in the Pulse metric definition. This change will flow through to all integrated dashboards, and spaces, ensuring everyone is still on the same page instantly.
• Increase in Speed to Insight: Because this layer is proactive, users aren’t hunting for data anymore, they are simply responding to the same insights. This shifts your analytics team from simply report builders, to strategic advisors. 
• Metric Layer becomes the Trust Layer: By certifying your Pulse metrics (in the governance set of Metric Definition of step 1), users can build confidence in their Pulse metrics, which eventually will lead to a culture of data.

Why centralize your business logic in the Metric Layer?

The introduction of the Metric Layer is the shift in how we think about data strategy. We are moving away from an era where users had to go “hunting” for answers in a forest of static dashboards. Instead, we are building a foundation where the data finds the user.

By centralizing your business logic in the Metric Layer, we aren’t just cleaning up your reporting, we are building an AI-ready infrastructure. Whether you are using Pulse today or preparing for the AI agents of tomorrow, the Metric Layer ensures that your “single source of truth” is actually true.

The dashboard isn’t going away, it’s just getting a promotion. It is no longer the place where you go to find out what happened—it’s the place where you go to decide what to do next.

The post Single Source of Truth: The Tableau Pulse Metric Layer appeared first on Atrium.

This is where Snowflake Horizon Catalog comes in. It provides a unified approach to solving today’s governance challenges.

Snowflake Horizon empowers organizations to govern and discover data through a built-in, unified set of compliance, security, privacy, interoperability, and access capabilities for data, apps, and models in the AI Data Cloud. With Horizon, data teams can find, understand, and govern data at scale, improving trust, quality, and productivity across the organization.

As organizations adopt cloud platforms and AI-driven analytics, the need for modern data governance becomes critical. Snowflake Horizon Catalog addresses this challenge by embedding governance directly into the data platform, enabling organizations to manage security, compliance, and data access more efficiently.

Why organizations need the Snowflake Horizon Catalog

Centralized security and control

Problem

Data is spread across multiple clouds such as AWS, Azure, and GCP, making it difficult to manage threats and user access.

Traditional approach

Teams rely on manual audits, separate security tools, and disconnected governance systems. This fragmented approach often creates security gaps and increases operational overhead.

Solution

Snowflake Horizon Catalog acts like a centralized governance layer across cloud environments. It monitors threats from one place and ensures that only the right users access the right data through role-based access control.

Easy and powerful data protection

Problem

Protecting every table, file, and column using custom rules can be time-consuming and prone to errors.

Traditional approach

Legacy environments often rely on custom scripts or duplicate tables to hide sensitive information. This leads to stale data copies and inconsistent protection.

Solution

Snowflake Horizon Catalog provides built-in, proven security controls that can be applied instantly. It enables granular protection, allowing teams to secure individual columns rather than entire datasets while maintaining centralized governance.

Faster discovery and safe collaboration

Problem

Finding the right data, applications, or models can be time-consuming, and sharing sensitive data across teams increases risk.

Traditional Approach

Data discovery often depends on static documentation or spreadsheets. Collaboration frequently requires copying or moving data, which increases the risk of duplication and data leakage.

Solution

Snowflake Horizon Catalog enables natural language search to quickly locate relevant data assets. It also allows teams to collaborate securely while automatically protecting sensitive information through masking and policy-based controls.

Who benefits?

Data governors and stewards

Snowflake Horizon Catalog enables data stewards to govern organizational content with built-in tools. They can identify sensitive data, apply governance policies, monitor usage, and assess data quality.

Data teams (analysts, data scientists, and data engineers)

Data teams can discover, evaluate, and understand the data, apps, and models they need. They can verify whether data is trustworthy, request access when needed, and focus on generating insights instead of navigating governance complexity.

Pillars of the Snowflake Horizon Catalog

Compliance

Monitor and protect data with governance tools designed for scale.

• Access history and lineage to track usage and dependencies
• Data quality monitoring with out-of-the-box and custom metrics
• Lineage visualization showing relationships between tables and views
• Object tagging and classification to identify sensitive data fields

Security

Protect data using built-in encryption, authentication, and governance policies. The Snowflake Trust Center provides a cross-cloud security dashboard with risk insights and recommended actions.

Privacy

Enable secure collaboration through privacy policies, data masking, clean rooms, and synthetic data generation for safe data sharing.

Discovery

Search and explore data assets—including dashboards, apps, worksheets, and data products—through universal search and the Snowflake Marketplace.

Collaboration

Share governed data across regions without ETL pipelines or duplicate copies. Organizations can also exchange data, apps, and AI products through unified billing.

Key takeaways

As data continues to grow across clouds, teams, and regions, governance becomes increasingly complex. Traditional approaches relying on manual controls, disconnected tools, and duplicated datasets often slow teams down and increase risk.

Snowflake Horizon Catalog addresses these challenges by embedding governance directly into the data platform, helping organizations implement modern data governance while maintaining security, compliance, and data visibility.

Main highlights:

• One place to control and monitor data access
• Built-in protection for sensitive data, even at the column level
• Faster data discovery with better visibility and context
• Secure collaboration without copying or exposing sensitive data
• Improved trust in data through quality monitoring and lineage

For organizations, Snowflake Horizon Catalog reduces risk and strengthens compliance. For data teams, it saves time and allows them to focus on insights rather than governance tasks.

In short, Snowflake Horizon Catalog brings governance, discovery, and collaboration together so teams can focus on driving value instead of managing complexity. Are you ready to modernize your data governance with Snowflake Horizon Catalog?

The post Horizon Catalog: Redefining Data Governance with Snowflake appeared first on Atrium.

Modern analytics isn’t a choice between Pulse metrics and dashboards. Instead, it is a three-tiered approach to decision-making where each tool has a specific job to do.

The awareness layer: Tableau Pulse

The role of Tableau Pulse is to handle the noise. It acts as a proactive monitor, scanning thousands of data points to find the outliers that require human attention. Rather than asking a user to hunt for a problem, Pulse serves as the curator of information.

For example, consider a fulfillment organization. Market leaders need to know which of their hubs are experiencing shipping delays. Instead of checking a massive report daily, they use a Pulse metric to track Order-to-Ship Latency.

Looking at the metric above, it is clear that latency is increasing throughout the month. At this stage, the user has been alerted to a trend, but they need more context to understand the root cause.

The discovery layer: Enhanced Q&A

This is where Enhanced Q&A enters the workflow. Now that the leaders know latency is up, they can explore the “why” by interacting directly with the metric using plain English. Questions like Which fulfillment hub has the highest latency? or What products are driving these delays? allow them to dive deeper into the data.

This discovery phase turns a vague alert into targeted intelligence. By the time the user moves to the next step, they aren’t just looking for problems—they are looking for specific solutions.

The action layer: the Tableau dashboard

Now that the team knows where the problems are located, they are ready to take action. This is where the traditional Tableau dashboard becomes the hero of the story. While Pulse and Q&A help us understand what happened, the dashboard allows us to see the big picture and plan the path forward.

As we navigate to the dashboard, you’ll notice something important: the Pulse metrics for Latency and Priority Orders appear directly at the top. This integration ensures that the “single source of truth” established in Pulse remains consistent throughout the entire ecosystem.

The true power of the dashboard appears in its ability to scenario plan in real time. By making adjustments to staffing levels via a slider, managers can see how reallocating resources will impact fulfillment speed across different regions. We see a map identifying geographic bottlenecks paired with a combo chart that visualizes the direct correlation between staffing drops and latency spikes.

Finally, the dashboard provides a detail table for row-by-row drill-downs. While Pulse and Q&A provide the “what” and the “why,” the dashboard provides the “who” and the “how”—listing the specific high-priority orders that need to be expedited immediately.

Moving toward a data-driven culture

The role of the Tableau dashboard has changed. It is no longer just a tool for displaying data; we have Pulse and Enhanced Q&A for that now. Instead, the dashboard has been elevated to the Action Layer. It is the environment where insights are transformed into strategic moves. In this modern framework, Tableau dashboards aren’t just relevant—they are the final, essential step in a data-driven culture.

The post Evolution, Not Reinvention: Tableau Dashboards in a Modern BI Strategy appeared first on Atrium.

Andi has continued to grow into a really good Salesforce developer, not just for configuration, but also for Apex. But what has me more than excited is that Andi has evolved well beyond development. We have expanded Andi’s focus from pure development into an agent that can cover the full Salesforce lifecycle, an assistant that can take an initial idea and create a detailed solution, develop that solution, write its own test cases, and run those test cases inside Salesforce.

In this blog, I’ll walk you through an end-to-end use case, so that you can see the power of contextually-aware AI design flowing seamlessly into AI development and cutting-edge agentic browser testing, all powered through one Salesforce AI Agent, Andi.

The use case

In order to demonstrate the breadth of what Andi can do, I figured I’d tackle a use case that has plagued many a Salesforce instance over the years: Approval Delegation. As many have experienced, standard Salesforce functionality allows assignment of a delegate for approvals, but that’s where the functionality stops. If you forget to assign a delegate before going out of office, or you have pending approvals you couldn’t get to before that week-long vacation, there’s no easy way to handle that in standard Salesforce.

Of course, Salesforce is one of the most customizable platforms on the planet, and so with a little work, we can build that functionality, and I’m going to use Andi to do all of it.

Andi as solutioning agent

To start creating the above solution, I enter the following starter prompt into the Andi web interface:

I need to create a solution that solves handling approvals when someone goes on vacation. I effectively want to create a Smart Out-of-Office Approval Routing system that closes the gap in Salesforce where there’s no start or end date associated with Delegated Approvers. As part of the solution, I need to do the following:

1) Track upcoming start/end dates for vacations
2) Insert a check to make sure that when a new request is routed for approval that the person isn’t on vacation; if they are, route to the delegate
3) Check existing pending requests in a user’s queue and reassign to a delegate when they start on vacation
4) Make sure that new requests that come in after the end date of the vacation are not routed to the delegate

Can you help me lay out how to solve this in my Salesforce instance?

Andi immediately goes to work. But here’s where Andi is different from other LLMs. Instead of creating a generic solution, Andi has full contextual awareness of my Salesforce org, meaning it understands the entirety of what already exists in my org, as well as common patterns that allow it to design a solution that is right for my org without creating additional technical debt.

Note what Andi says at the end: “Before I get into the specific implementation details, I’m going to quickly analyze your org’s existing metadata. This will help me understand your current automation pattern and check if you already have any similar objects or fields that we could use.”

This isn’t a generic solution in a vacuum; it’s Andi designing specifically for the org in which it is working. To further enhance this feature, we’ll be releasing Supplementary Context uploads at the end of March 2026. This will allow Andi customers to add their own intelligence to Andi— in the form of files like development standards, naming conventions, or design documents—that will make Andi even more intelligent in how it solutions.

In our example above, Andi actually found a few components that already exist, namely the Out_of_Office__c object, as well as an Apex class that might solve our reassignment piece. 

After identifying some potential custom object matches, it further evaluates the fields on those objects.

It correctly concludes that the Out_of_Office__c object has all of the fields needed, and lets us know we can skip this part of the development process.

There’s still development work to do, however, and so we’ll move on to building our “intercepting” before-save Flow for new approval assignments.

Andi as development agent

Andi started out as a developer, but its capabilities continue to evolve. In addition Andi’s best-in-class ability to create complex Salesforce configuration like Flows, it can also fill in as an expert Apex developer, both creating or modifying custom code in your Salesforce system.

In order to get our Smart Out-of-Office Approval Routing system ready to go, we need to build that before-save Flow. I worked with Andi to come up with the ideal solution. As Andi evaluated options, it pointed out that the cleanest way to handle this scenario was to add an Approver field to the Opportunity object that we could default to the standard approver (in this case, the Opportunity Owner’s Manager) on creation, but one that we could then update with the appropriate approver when that Manager was on vacation. After using Andi to add that field, we moved forward to build the Flow. Andi had a few clarifying questions and then proceeded to knock out the Flow in under 2 minutes.

To quickly check the work, I had Andi give me a link:

But wait! There’s more! Let’s now test this Flow.

Andi as QA agent

Why stop with development? Andi can now write and execute its own test cases as well. I gave it a simple prompt—”can you write me a test case for this flow?”—and it didn’t disappoint. It transferred me to the QA Agent, and then returned *seven* test cases in under a minute I could use to validate the Flow satisfied the business requirements:

I have generated a comprehensive set of test cases for the “Set Opportunity Approver Before Save” flow. They cover positive scenarios, negative conditions, and boundary cases to ensure the logic is robust.

Please review the following test cases. Let me know if they look correct or if you’d like any changes. Once you approve, I can proceed with executing them.

Generated Test Cases for: Set_Opportunity_Approver_Before_Save

Flow Description: Before-save on Opportunity: When Amount > 100k and Stage is ‘Proposal/Price Quote’, this flow sets the Approver__c field. It assigns the owner’s manager as the approver, unless the manager has an active ‘Out of Office’ record, in which case it assigns the designated delegate.

Test Case 1: Positive: Approver set to Manager

• Description: Validates that when an Opportunity is created with Amount > 100k and Stage ‘Proposal/Price Quote’, and the owner’s manager is NOT out of office, the Approver__c field is set to the manager.
• Steps:
  • Create an Opportunity with Amount = 150,000 and Stage = ‘Proposal/Price Quote’.
  • Verify that the Approver__c field on the new Opportunity is set to the ID of the Opportunity Owner’s Manager.

Test Case 2: Positive: Approver set to Delegate

• Description: Validates that if the owner’s manager has an active ‘Out of Office’ record, the Approver__c is set to the specified delegate.
• Steps:
  • Create an active Out_of_Office__c record for a Manager, specifying a Delegate.
  • Create an Opportunity owned by a user who reports to that Manager, with Amount = 200,000 and Stage = ‘Proposal/Price Quote’.
  • Verify that the Approver__c field on the new Opportunity is set to the ID of the Delegate user.

Test Case 3: Negative: Amount does not meet criteria

• Description: Validates that the flow does not set the Approver__c field when the Opportunity Amount is not greater than 100k.
• Steps:
  • Create an Opportunity with Amount = 99,000 and Stage = ‘Proposal/Price Quote’.
  • Verify that the Approver__c field on the new Opportunity is null.

…

(and 4 additional test cases)

_____________

Would you like me to execute these tests?

Of course, I would like Andi to execute the tests. I asked it to run the first test.

The test failed, but simply because I didn’t have any data set up in the system. At this point, I had two options: I could manually set up my data, or I could modify my test case to tell Andi what to use in its test scenario. Either works well, and you can see how Andi’s QA capability can really help complete the end-to-end process.

End-to-end vibe solutioning and execution with Andi

You can clearly see the opportunities for efficiency. No swivel-chairing between tools, no handoffs between several people; a single user with an understanding of the business requirement and a basic modicum of Salesforce technical aptitude can now run an entire story, from conception through testing, using a single tool: Andi.

This is not to say that it needs to be one human, or that you shouldn’t have additional humans-in-the-loop validating the outputs along the way. But Andi moves way beyond “vibe coding”; this is end-to-end vibe solutioning and execution, from design through development and testing. It’s the next frontier of Salesforce system modification, and Andi is leading the way.

The post From Concept to QA: What a Full-Lifecycle Salesforce AI Agent Actually Looks Like appeared first on Atrium.

Enter Agent Script, the underlying compiled language specifically designed by Salesforce for building Agentforce agents. Available in the builder’s Script view or locally via the Agentforce DX VS Code Extension, Agent Script provides a developer-friendly environment with syntax highlighting, autocompletion, and validation.

Let’s dive into the core features of Agent Script and explore how dropping down into the code gives you unprecedented control over your Agentforce deployments.

The hybrid approach: Merging logic and LLM reasoning

The most powerful aspect of Agent Script is that it bridges the gap between declarative, procedural, and natural language programming. Relying entirely on an LLM to interpret instructions can sometimes lead to unpredictable behavior. Agent Script solves this by combining the flexibility of LLM interpretation with the reliability of programmatic expressions.

In Agent Script, you can define specific execution paths using two distinct syntax markers:

• Logic Instructions (->): These run deterministically every single time. You use them for running actions, defining if/else business rules, and setting variables.
• Prompt Instructions (|): These represent the natural language sent directly to the reasoning engine, allowing the LLM to interpret how to respond to the user.

By combining these side-by-side, you can guarantee that a workflow—like verifying an account or checking an order status—executes predictably before the LLM takes over to craft the customer-facing response.

Explicit state management via variables

In the Agent Builder UI, you might rely heavily on the LLM’s conversational memory to maintain context. Agent Script introduces robust, explicit state management through the variables block. By relying on deterministic variables rather than LLM context memory, you make your agent significantly more reliable.

Agent Script supports several variable types, including:

• Regular Variables: Mutable or immutable variables with types like string, number, boolean, list, and object.
• Linked Variables: Variables whose values are directly tied to an external source, such as the output of an action.
• System Variables: Predefined variables, such as @system_variables.user_input, which explicitly captures the customer’s most recent utterance.

Variables can be injected dynamically into LLM prompt instructions using the {!@variables.<variable_name>} syntax.

Granular control: Actions vs. tools

While the Canvas view groups capabilities together, Agent Script explicitly differentiates between Topic Actions and Reasoning Actions (Tools).

1. Deterministic Actions: If you want an action (like an Apex class, Flow, or Prompt Template) to run every single time a topic is parsed, you use the run @actions.<action_name> command within your logic instructions. This is perfect for data-fetching before the LLM begins reasoning.
2. Tools for the LLM: If you want the LLM to subjectively decide whether to invoke an action based on context, you expose it in the reasoning.actions block.

Agent Script also introduces the available when parameter, giving you the power to conditionally show or hide a tool from the reasoning engine based on current variable states (e.g., available when @variables.verified == True).

Advanced flow of control and routing

Every agent built with Agent Script begins execution at a special block called start_agent (known as the “Topic Selector” in the Canvas view). This block serves as the entry point for topic classification and routing.

From there, developers can orchestrate complex transitions using the @utils.transition to command. Transitions in Agent Script are strictly one-way; once executed, the agent halts the current directive block, discards the existing prompt, and immediately passes control to the new topic.

Alternatively, you can delegate control by referencing a topic directly (@topic.<topic_name>) inside your reasoning actions. Unlike declarative transitions, a direct topic reference acts like a standard tool call—once the delegated topic completes, the flow of control returns to the original topic.

Developer experience (DX) first

Agent Script is whitespace-sensitive, utilizing indentation to indicate structure much like Python or YAML. Because it is a compiled language that translates down to lower-level metadata, it integrates beautifully into the modern Salesforce developer workflow.

Instead of making changes purely in a UI, advanced developers can use Agentforce DX to pull the script file into their local Salesforce DX project. From there, you can leverage the Agentforce DX Visual Studio Code extension for standard code editing, version control, and CI/CD pipelines.

Why adopt Agent Script?

While the Agent Builder Canvas view is excellent for rapid prototyping and simple use cases, Agent Script is where the true power of Agentforce lies. By adopting Agent Script, developers gain the ability to chain actions deterministically, enforce strict if/else conditional logic, and precisely engineer the context passed to the LLM. If you are building enterprise-grade AI agents, it’s time to switch to the Script view.

The post Unlocking Deterministic AI: A Developer’s Deep Dive into Agentforce Script appeared first on Atrium.

What if it was possible to stop fixing broken connections and just let the data flow?

Why traditional integration falls short

Picture this: your sales data lives in Salesforce, marketing metrics are trapped in HubSpot, financial information sits in QuickBooks, and customer support data resides in Zendesk. Each system speaks its own language, creating data fragments that prevent organizations from gaining comprehensive insights. Traditional data integration approaches often involve complex coding, connections that break frequently, and maintenance nightmares that drain resources. Teams spend more time fixing broken pipelines than extracting valuable insights from their data.

Introducing Snowflake’s OpenFlow

Snowflake OpenFlow is the simple, powerful answer to this chaos. Think of it as a powerful data connection system, built directly into Snowflake. Its main job is to move data from all those different, scattered sources and bring it safely into Snowflake. Instead of writing complex code that breaks easily, OpenFlow provides a clean, visual way to build these data connections. Users simply connect their source, like Salesforce or a marketing platform, to their destination in Snowflake, and OpenFlow handles the rest.

Why OpenFlow matters in the Snowflake ecosystem

The true value of Snowflake’s OpenFlow tool lies in its native integration with the Snowflake platform. In the past, businesses had to buy and manage separate, third-party tools just to get their data into Snowflake. This created an inefficient, expensive, and unreliable system, often meaning two different vendors, two bills, and two platforms that could break. OpenFlow eliminates this completely. It isn’t an add-on; it is built directly into the platform. This creates a single, seamless experience, which means unmatched reliability, lower costs, and a much simpler way of working, empowering data teams to deliver value instead of just managing integrations.

Openflow in action

OpenFlow’s most compelling feature is its visual, drag-and-drop interface, which turns complex data integration into intuitive workflows. Users can see their data connections, making it easy to understand, modify, and troubleshoot.

Imagine a flowchart where boxes are your data steps and arrows show its movement. This visual layout allows everyone, from analysts to data scientists and even non-technical stakeholders to understand and contribute. The days of “black-box” integrations that only one developer understands are finally over.

Seeing OpenFlow in action highlights its simplicity. It’s built right into the Snowflake interface, so no separate setup is needed. Just head to the Ingestion section, and you’ll find it waiting.

Click on it, and you’re greeted with a clean overview page that explains what OpenFlow does: connect data from any source to any destination. From here, you can launch a workspace, which opens a blank visual canvas to design and manage your data pipelines.

Here’s what a working flow looks like inside OpenFlow:

In this example, the flow starts by reading from a source table, updating or transforming the data, and then writing it back to a Snowflake target. You can see the steps clearly on the canvas, from QueryDatabaseTable to UpdateRecord to PutDatabaseRecord. The interface shows task details, run times, and data volumes in real time, so you always know what’s happening.

For anyone building or managing data workflows, this experience feels both familiar and refreshing. It’s a modern, hands-on way to simplify complex data movement, one flow at a time.

Current OpenFlow features: What OpenFlow delivers today

So, what can OpenFlow actually do right now? Its power is in its practical, everyday features. This isn’t just a concept; it’s a tool ready to work. It gives teams a clean, visual workbench to build data pipelines, think more “connecting the dots” and less “writing complex code.”

These connections are also impressively smart. If your source data suddenly changes, like a new column is added, OpenFlow can automatically adapt without breaking. It comes with pre-built connectors for common apps, and it’s flexible. It can move data at a planned time (like a daily report) or instantly as it happens.

You can even clean and filter data while it’s moving, ensuring it lands in Snowflake pure and ready for analysis. Best of all, it’s built to be reliable. It automatically handles errors and gives you a single place to see how everything is running, all protected by the same security you already trust.

Atrium’s POV

OpenFlow’s real value isn’t just its features, but how it shifts a team’s entire focus. It moves the conversation away from the technical headaches of data movement and starts talking about what the data can do for the business. This lets us help companies build new, data-driven solutions with a speed that wasn’t possible before.

Imagine a retail brand was using a costly third-party tool to ingest sales data from hundreds of store systems. This process was brittle, frequently failing and leaving analysts without data for morning reports. By replacing this external tool with Snowflake OpenFlow, they built a reliable, native workflow. This move eliminated a significant license fee and ensured that complete, accurate sales data was in Snowflake, ready for analysis, every single morning.

What’s new: Latest release highlights

Snowflake OpenFlow is now a production-ready service, making data integration smoother and faster than ever. Launched in May 2025 to connect any data source, structured or unstructured. It now runs on Snowpark Container Services for enterprise-grade scale and stability.

• Recent updates have focused on expanding connector libraries, improving performance optimization, and enhancing security features. 
• New capabilities include advanced data lineage tracking, which helps organizations understand data flow and maintain compliance requirements. 
• Enhanced monitoring dashboards provide real-time visibility into integration health and performance metrics.

The future of data integration is here

Snowflake OpenFlow simplifies data movement and speeds up the design of ingestion methods for diverse data types. As data volumes and business demands grow, Snowflake becomes essential for competitive advantage.

The question isn’t if you need better data integration, but whether you are ready for the future of seamless, visual, and powerful connectivity Snowflake provides. Reach out to us if you are looking to simplify your Snowflake data ingestion and need to smoothen your data operations using Openflow.

The post Snowflake OpenFlow: Simplify Complex Data Workflows appeared first on Atrium.

With any technology that has served as the industry leader, competitors have come into the fold with their own niche. With the rise of these competitors, Tableau has often been seen as an outdated technology. However, over the past few years, Tableau has taken great strides to push their technology toward the forefront of BI modernization in the age of AI and data insight.

Why Tableau introduced Tableau Pulse

In the current era of analytics, many organizations are dealing with what I like to call report overload. Especially within a technology as seasoned as Tableau, many organizations may have hundreds, even thousands of reports, that they have accumulated over the years. This can lead to an influx of information which causes users to be overwhelmed, and simply ignore the insight all together. On top of that, Tableau dashboards can often be overly complex, which can leave the analysis muddled.

That’s why Tableau introduced Tableau Pulse. Rather than a large and complex dashboard, Pulse is distilled down to single metrics that can show trends over time. These metrics are optimized for mobile-first experience, delivering personalized insights directly to a user’s workflow.

This isn’t just about a cleaner interface. It is a fundamental shift from what’s called “pull” to “push” analytics. In the past, being data-driven meant a user had to remember to log in and go on a scavenger hunt through various tabs, forcing the dashboard to try to pull users to their insights.

With Pulse, the insights come to where the work is actually happening. Whether through email digests or direct notifications in Slack and Microsoft Teams, it moves the technology from a destination you visit to a partner that keeps you informed in real time. The analytics is pushed out to your users on a daily basis.

Solving the governance gap

One of the common critiques of aging BI platforms is the mess of ungoverned data. In older environments, three different people could have built three different sales dashboards, all showing different numbers for the same metrics. Oftentimes, they aren’t even aware these other reports conflict with each other because of this lack of governance. Tableau Pulse was introduced to create what is called a “metric layer.”

In the metric layer, the logic for a metric is defined once, such as Gross Margin or Total Revenue, and that metric definition is consistent across all user’s experiences. These metrics can be shared and followed by any user (with the proper permissions), allowing for these metrics to be universal across your organization. This develops a single source of truth across companies, and removes redundancies in reporting. 

Mobile insights & subscriptions first

Tableau has always been the leader when it comes to mobile dashboard design. Few tools allow for users to optimize both mobile and desktop layouts on the same dashboard. Still, this process required Tableau developers to pre-design both versions of the same dashboard for both screen settings.

Tableau Pulse, however, is pre-designed for both mobile and desktop with no additional formatting required. Pulse is visible as an application on smartphones, meaning users can start their day by opening up their metrics to get a pulse on what’s been happening. Even if users aren’t checking their metrics daily, once a user follows a metric, any sudden changes will be flagged and sent as an email or notification. This pushes users directly to the data and ensures that stakeholders stay up to date, driving data-centered decision making without the manual effort.

Enhancing Pulse with Enhanced Q&A

Pulse is a rockstar at metric tracking, but what else can it do? The real shift comes with the integration of Enhanced Q&A. While previous versions of natural language querying feel rigid, Enhanced Q&A allows for users to interact directly with their data using natural language. This feature is Tableau stepping out from its role as best-in-class analytics reporting toward the world of agentic insights.

Standard dashboards are great to show what has already happened, like your user base increasing by 10%, or sales dropping quarter-over-quarter. Pulse Enhanced Q&A moves it toward answering the question “Why did this happen?” If a metric you’ve defined suddenly drops, a user can immediately jump in and ask questions such as “What drove the decrease in sales last week?” or “What products experienced a drop in sales last week?” Enhanced Q&A will respond with a summarized explanation of the underlying drivers of the change. It transforms Tableau from a visual library into a conversational partner. This actionability means that your non-technical users no longer have to wait on analytics to be developed, and can get insights in the moment.

Modernize your analytics stack with Tableau Pulse

Tableau may be a seasoned technology, but it’s far from out of date. By moving from the one-size-fits-all dashboard and toward personalized, AI-driven experiences found in Pulse, Tableau has redefined how it runs analytics. For organizations looking to cut through the noise of report overload, Tableau Pulse is the answer to simplify and modernize your analytics stack. Don’t just build reports—build actions with Tableau Pulse.

The post How Tableau Pulse is Modernizing Tableau appeared first on Atrium.

These are the problems the February release was built to solve.

This month’s update introduces the Org Context Engine — a foundational shift in how Andi understands your Salesforce org — alongside meaningful upgrades to Validation Rules, Permission Sets, and post-deployment navigation. Together, these changes move Andi from a task executor into an org intelligence layer that helps teams troubleshoot, plan, and build with full context.

Here’s what’s new:

Org Context Engine: Your Salesforce org, fully indexed

This is the headline feature of the February release, and it changes what’s possible with Andi.

The Org Context Engine takes a new approach to metadata awareness. It maintains a deep, local index of your org’s metadata, giving Andi a persistent, structured understanding of your objects, fields, automations, Apex classes, Validation Rules, and more.

The practical impact is significant. Instead of asking Andi to find a single component, teams can now ask complex, cross-cutting questions and get immediate answers.

Deep troubleshooting. A field is being modified unexpectedly. Rather than manually auditing Triggers, Flows, and Workflow Rules one at a time, ask Andi to search across all of them simultaneously. For example: “What automations could be modifying the Account.BillingAddress field?” Andi will return a consolidated view of every automation that touches it.

Impact analysis. Before deprecating a field, renaming an object, or refactoring a trigger, teams need to know what depends on it. Andi can now trace where a specific field is referenced across Apex classes, Flows, and Validation Rules — giving teams a clear scope of impact before any change is made.

Org inventory and onboarding. New to the org? Ask Andi for a summary of metadata — total Apex classes, active Flows, custom objects — or ask it to explain what a specific trigger or class does. This turns weeks of tribal-knowledge gathering into a single conversation.

Intelligent solution design. When building something new, Andi can analyze existing patterns in the org and suggest configurations that stay consistent with the current architecture, reducing the risk of conflicts or redundant logic.

When Andi surfaces a finding, it points teams to the exact location in Salesforce Setup where that component can be reviewed or edited.

Validation Rules: Faster and more reliable

The Validation Rule engine has been rebuilt from the back end. Complex rules now deploy consistently, even those with multiple conditions, cross-object references, or nested logic.

This matters most for teams managing orgs with dense business logic. Sophisticated validation rules deploy reliably, and the overall creation workflow is faster.

This upgrade also pairs well with the Org Context Engine. Before building a new rule, teams can ask Andi to show all active validation rules on the target object. This makes it easy to spot redundant logic or potential conflicts before they’re introduced.

Direct Artifact Links: One click from creation to configuration

A small change with an outsized impact on daily workflow. When Andi successfully creates or updates a Flow, Validation Rule, Field, or other metadata component, the confirmation message now includes a direct hyperlink to that component in Salesforce Setup. Click the link, land directly on the component, and continue working.

Intelligent Permission Sets: Secure by default

Permission set creation now includes automatic dependency resolution. When Edit access is requested on a field, Andi automatically enables the required Read access on that field and includes the necessary parent object permissions — without being asked.

Andi handles the dependency hierarchy automatically, ensuring the security model is valid from the start. Teams can focus on defining what access is needed and trust that the underlying structure will be correct.

As with Validation Rules, this pairs well with the Org Context Engine. Before creating a new permission set, teams can ask Andi to list all custom fields on the target object, making it easier to define a complete set of requirements up front.

Enhanced Page Layout editing

Building on January’s Page Layout improvements, teams can now add related lists, configure sections, and add or remove buttons directly through the chat interface. Combined with the partial update and deterministic deployment capabilities shipped last month, Page Layout management is now a faster, more conversational workflow.

What this release means for teams

February’s updates share a common theme: giving teams the context they need before they build, and removing friction after they do.

The Org Context Engine is the most significant capability Andi has gained since launch. It transforms Andi from a tool that executes individual tasks into one that understands the full picture of an org — its structure, its dependencies, and its patterns. That understanding makes every other action safer, faster, and more informed.

For teams managing complex orgs, onboarding new admins, or planning large-scale refactors, this release is designed to make that work meaningfully easier.

🚀 Ready to see what Andi can do for your team? Start your free trial today.

The post Andi February 2026 Release: Supercharge Your Org Intelligence appeared first on Atrium.

Why teams are migrating from Redshift to Snowflake

Most Redshift to Snowflake migrations are not driven by dissatisfaction.

They’re driven by strategic questions like:

• Can our data platform scale with usage and diverse workloads?
• Are our engineering resources focused on innovation or maintaining infrastructure?
• Do we trust our metrics across the business?
• Are we architected for AI, semi-structured data, and advanced analytics?
• Is our governance keeping pace with growth?
• Can we support enterprise apps, analytics, and data science on a single auto-scaling platform?
• Are we able to securely share and extend data across our ecosystem?

For organizations thinking about data architecture as part of long-term strategy, Snowflake represents a shift in operating model,  not just a new warehouse.

Snowflake vs. Redshift: The architectural shift

Both platforms are cloud data warehouses. The key difference is how they manage compute and storage.

Snowflake’s decoupled architecture allows teams to:

• Isolate ingestion, transformation, and BI workloads
• Scale compute without re-architecting
• Handle usage spikes gracefully
• Control costs at the workload level
• Bring business analytics, data science, and data engineering teams together on a single platform with integrated tooling

As analytics adoption grows, these differences become increasingly important.

Common reasons organizations make the move

Across industries, we typically see four drivers behind a Redshift to Snowflake migration.

Pipeline fragility & data trust issues

Over time, Redshift environments accumulate complexity:

• Distribution key tuning
• Manual maintenance tasks
• Hard-coded business logic
• Inconsistent metric definitions

As teams scale, this complexity leads to slower iteration and lower trust in reporting.

Snowflake simplifies physical design and makes it easier to centralize and govern transformation logic, which improves consistency and reliability.

Performance & concurrency limitations

As more users access the warehouse:

• Queries begin to queue
• Dashboards slow down during peak usage
• ETL jobs compete with reporting workloads

Snowflake virtual warehouses allow teams to isolate workloads and scale independently, reducing contention without architectural redesign. This shift moves teams from firefighting performance issues to focusing on uptime, reliability, and delivering consistent business value.

Growing need for governance

As data access expands across departments:

• Role sprawl increases
• Permissions become inconsistent
• Auditing becomes more important

A migration creates an opportunity to reset governance:

• Define clear role hierarchies
• Implement environment promotion standards
• Establish testing practices
• Monitor costs proactively

Governance isn’t just about compliance,  it’s about operational clarity.

AI & advanced analytics readiness

Organizations exploring:

• Predictive modeling
• Near real-time dashboards
• LLM use cases
• Data activation workflows

…require clean, governed, and well-structured data, a clearly defined semantic layer, and elastic compute.

Snowflake’s architecture supports these use cases, but only when implemented thoughtfully.

The migration often becomes the moment when teams modernize modeling standards and clean up technical debt.

A practical migration framework

While every environment differs, most Redshift to Snowflake migrations follow a structured path.

Assessment & planning

Strong migrations start by aligning architecture to strategy.

We begin by asking:

• What KPIs are most critical to the business?
• What should analytics-ready data products look like?
• How should domain-aware models be structured?
• How can we design a semantic layer that supports both BI and AI use cases?

Only then do we inventory objects, analyze workloads, and map dependencies. Clear scoping prevents surprises and ensures the new Snowflake environment is built for impact, not just compatibility.

Environment & security setup

• Design a Snowflake warehouse strategy
• Translate Redshift users and groups into Snowflake RBAC
• Configure SSO and network policies
• Establish dev/test/prod separation

Migration is often the right time to improve governance, not just replicate it.

Code conversion & modernization

One of the most time-intensive steps is translating Redshift SQL and objects into Snowflake-compatible syntax.

Snowflake’s SnowConvert AI can significantly accelerate this phase by:

• Automating large portions of SQL and DDL translation
• Flagging unsupported constructs
• Identifying areas requiring manual refinement

For many teams, SnowConvert reduces the manual effort involved in code conversion.

However, strong migrations go beyond automated translation. They also:

• Rethink Redshift-specific physical design assumptions
• Refactor stored procedures where needed
• Simplify legacy logic
• Align models to Snowflake’s execution patterns

The goal isn’t to recreate Redshift in Snowflake,  it’s to leverage Snowflake’s strengths.

Increasingly, modernization work is also being accelerated through Snowflake-native AI capabilities such as Cortex Code. Because Cortex operates within the Snowflake environment itself, with awareness of schemas, metadata, and architectural patterns,  it can assist with scaffolding dbt models, refactoring legacy logic, and debugging transformation failures in context.

When used thoughtfully, this reduces repetitive engineering effort while maintaining architectural standards. It doesn’t replace engineering judgment,  it enhances it.

As AI becomes embedded directly into the data platform, migration delivery is shifting from purely manual execution toward AI-augmented modernization.

Data migration

A common approach includes:

• Using Redshift’s UNLOAD to export data to S3
• Loading into Snowflake via COPY INTO
• Validating row counts and aggregates
• Benchmarking performance

Initial warehouse sizing and parallelization strategies can significantly impact migration speed.

Pipeline & BI transition

• Update ingestion jobs to target Snowflake
• Refactor transformation logic where modernizing
• Repoint dashboards and reporting tools
• Conduct performance testing

Workload isolation often results in immediate improvements for BI users.

Validation, cutover, & optimization

Before go-live:

• Conduct structured validation and UAT
• Perform final incremental sync
• Keep Redshift read-only temporarily as fallback

After migration:

• Right-size warehouses
• Enforce auto-suspend
• Monitor credit consumption
• Refine governance practices

Long-term value depends on how the platform is operated, not just how it’s migrated.

Lift-and-shift vs. modernization

Organizations typically choose between:

Lift-and-shift

• Faster execution
• Lower immediate disruption
• Preserves legacy modeling patterns

Modernization

• Cleans technical debt
• Standardizes models
• Improves governance
• Designs for scalability and AI use cases

Many teams choose a hybrid approach: migrate efficiently, then modernize in structured phases. The right answer depends on business urgency and long-term goals.

The bigger picture

Migrating from Redshift to Snowflake is not just a technical project.

It’s an opportunity to:

• Reset modeling standards
• Improve data trust
• Reduce operational overhead
• Enable higher concurrency
• Prepare for AI and advanced analytics

For organizations that view data architecture as part of long-term strategy, the migration decision should be aligned with where the business is headed — not just where the warehouse is today.

Data modernization and migration with Atrium

Atrium is an AI-native data modernization and Snowflake consulting partner. We help data-mature organizations migrate from Redshift to Snowflake using tools like SnowConvert — while designing scalable, governed, and future-ready data platforms.

If you’re evaluating a Redshift to Snowflake migration, we’re happy to share what a thoughtful, low-risk modernization path looks like.

The post Redshift to Snowflake Migration: A Strategic Guide for Modern Data Teams appeared first on Atrium.