> For the complete documentation index, see [llms.txt](https://docs.pharos.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/logs/log-presentations/flow-and-process-builder-logs.md).

# Flow and Process Builder Logs

Learn about Flow and Process Builder log presentations including the flow debugger and element-level execution tracking.

Flow and Process Builder logs in Pharos provide visibility into declarative automation execution with specialized presentations that map abstract execution traces back to the visual elements administrators and developers recognize from the Flow Builder interface.

## Understanding Flow Log Challenges

Flows execute declaratively, yet when errors occur their underlying debug logs contain technical execution details that are difficult to interpret without context.

{% hint style="info" %}
**From Technical to Visual**

Flow execution logs are notoriously difficult to interpret because they contain technical execution details rather than the visual element names and paths you see in Flow Builder. Pharos bridges this gap.
{% endhint %}

Flows execute declaratively—defined through point-and-click configuration rather than code—yet when errors occur, the underlying debug logs contain technical execution details that can be difficult to interpret. A Flow element like "Decision: Check Inventory Levels" appears in the log as an anonymous decision node with an execution timestamp and variables values, but without context about which specific element ran or which path was taken.

Process Builders face similar challenges, with evaluation criteria and actions that fire based on record changes producing logs that reference internal identifiers rather than the criteria names shown in the Process Builder UI.

Pharos bridges this gap by parsing Flow and Process Builder execution logs and reconstructing the visual flow of execution, making it clear which elements ran, in what order, and with what data.

## Flow Debugger Interface

When viewing a Flow log in Pharos, the **Debug** tab activates a Flow-specific debugger that presents execution as a traversal through the Flow's elements rather than as a linear log file.

### Execution Tree View

The execution tree shows the hierarchical path through the Flow, with each element that executed appearing as a node using its configured label from Flow Builder—making it immediately clear which decision, assignment, or action ran.

| Feature                         | What It Shows                                                                 | Debugging Value                           |
| ------------------------------- | ----------------------------------------------------------------------------- | ----------------------------------------- |
| **Stepping Through Execution**  | One element at a time with input variables, criteria evaluations, and outputs | Navigate execution frame-by-frame         |
| **Decision Path Visualization** | Which criteria were evaluated and which outcome path was taken                | Understand branching logic clearly        |
| **Loop Iteration Tracking**     | Each iteration as separate entry with collection values                       | Reveals loop count and per-iteration data |
| **Subflow Invocations**         | Nested subflow execution beneath parent call site                             | Complete context across Flow boundaries   |

### Variable State Inspection

As you step through Flow execution, the **Variables** panel displays the current state of all Flow variables at that point in execution:

* **Resource values:** Variables, constants, formulas
* **Record variables:** Field values for records being processed
* **Collection variables:** Number of items and their contents
* **System variables:** `$Record`, `$User`, and other built-in references

{% hint style="success" %}
**Time-Travel Debugging:** If a record field that should contain a value is null, you can step backward through execution to find where the assignment failed or was skipped.
{% endhint %}

### Element Details Panel

Selecting any element in the execution tree displays detailed information about that specific execution step. This level of detail eliminates guesswork about what happened inside each Flow element.

| Element Type                                  | Details Shown                                                                                   |
| --------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| **Assignment**                                | Variables assigned, values received (literals + formula evaluations), source of values          |
| **Decision**                                  | Each outcome criteria (true/false), which outcome selected and why, resource values in criteria |
| **Record Actions** (Get/Create/Update/Delete) | Object type, filter criteria, field values set, record IDs affected, number processed           |
| **Action Elements** (Invocable)               | Apex class/Flow action invoked, input parameters, output values, success/failure status         |

## Process Builder Log Presentation

Process Builders generate logs similar to Flows but with specific presentation considerations due to their criteria-based evaluation model.

### Criteria Evaluation Display

Process Builder logs show which evaluation criteria were checked and which matched the triggering record's data. When multiple criteria exist with different orders of execution, the log clarifies which criteria caused which actions to fire.

**Entry Criteria** — The overall Process Builder entry criteria evaluation is shown first, indicating whether the process ran at all for the triggering record.

**Node Criteria** — Each decision node's criteria are evaluated in order. The log shows which node(s) matched and which were skipped based on the "stop on first true" or "evaluate all" configuration.

**Scheduled Actions** — If the Process Builder schedules actions for future execution, those scheduled actions are tracked and linked to the original Process evaluation that created them.

### Action Execution Details

Process Builder actions (Create Record, Update Record, Call Apex, etc.) are presented with similar detail to Flow actions:

* Target records and field values
* Apex classes invoked with parameters
* Email alerts sent with recipient details
* Errors encountered during action execution

When a Process Builder action fails, the log isolates that specific action and its error message, rather than obscuring it within the overall process execution.

## Common Flow/Process Builder Fields

Beyond the debugger interface, Flow and Process Builder logs include standard metadata fields for complete execution context:

| Field Category          | What's Included                                                                                                      | Purpose                                               |
| ----------------------- | -------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- |
| **Flow Metadata**       | API Name, Label, Version Number, Flow Type (Screen/Auto/Triggered/Scheduled), Trigger Context (Insert/Update/Delete) | Identify which flow version executed                  |
| **Execution Context**   | Triggering User, Triggering Record ID, Interview GUID                                                                | Track who/what initiated execution                    |
| **Performance Metrics** | Element execution time, total duration, DML consumed, SOQL consumed, governor limits                                 | Identify performance bottlenecks in specific elements |

## Error Scenarios and Debugging

Flows can fail in several common scenarios, each presented distinctly to accelerate troubleshooting:

| Error Scenario                  | What the Log Shows                                                                                 | Debugging Insight                                                                |
| ------------------------------- | -------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| **Unhandled Faults**            | Element that threw fault, fault message/type, potential fault path, failed records/operations      | Whether error should be handled with fault connectors or needs configuration fix |
| **Failed Record Operations**    | Expected vs. actual records affected, filter criteria, skipped elements                            | Identify overly restrictive criteria or empty collections                        |
| **Screen Flow Abandonment**     | Screens visited, where user exited (closed/navigated away)                                         | Identify confusion points or friction in guided processes                        |
| **Validation/Trigger Failures** | Validation rule/trigger that rejected operation, field values that caused failure, handling status | Understand data quality issues or missing error handling                         |

## Interpreting Loop Behavior

Loops in Flows can be a source of unexpected behavior—processing too many or too few items, or performing actions incorrectly within iterations. The Flow debugger makes loop behavior explicit:

**Iteration Count** — Total number of times the loop executed, confirming whether the collection size matched expectations.

**Per-Iteration State** — Expanding each iteration in the execution tree shows what happened during that specific pass through the loop, including which elements ran and what variable values existed.

**Premature Exit** — If a loop exits early (due to an error or empty collection), the log indicates why the loop stopped before processing all expected items.

This visibility helps diagnose issues like "The loop only processed 3 records when there should have been 10" or "The assignment inside the loop didn't update the variable correctly."

## Flow Versions and Active Flow Tracking

When multiple versions of a Flow exist in an org, logs clearly indicate which version executed. This is critical when troubleshooting an issue that may have been introduced in a recent flow update.

If an older version is still processing scheduled actions or running via Process Builder callouts, the log will reflect that older version number, helping explain why behavior differs from the currently active version.

## Integration with Issue Tracking

Flow errors are fingerprinted and grouped into Issues just like other log types. The fingerprint for a Flow error typically includes:

* Flow API Name
* Failing element label or type
* Error message pattern

This grouping enables analysis of how many times a specific Flow element fails across different executions, different users, or different triggering records. From an Issue detail page, you can see all occurrences of that Flow error and identify whether it's user-specific, data-specific, or systemic.

## Screen Flow Debugging Considerations

Screen Flows present unique debugging challenges since execution includes user interaction and waiting periods. Pharos logs capture:

**Screen Loads** — Which screens were displayed to the user and when.

**User Input Values** — Data the user entered into screen components (text fields, picklists, etc.).

**Validation Errors** — If screen-level validation rejected user input, those messages are captured.

**Navigation Actions** — Which buttons the user clicked (Next, Previous, Finish) to move between screens.

This creates an audit trail of user interaction that can reveal whether errors stem from unexpected user input or from business logic problems in the Flow itself.

## Summary

Flow and Process Builder log presentations in Pharos transform technical execution logs into visual debugging experiences that mirror the declarative interfaces used to build these automations.

**Key Capabilities:**

* **Execution Tree View:** Hierarchical path through Flow elements with stepping, decision paths, loop tracking, subflow nesting
* **Variable State Inspection:** Real-time view of all variables, resources, collections, and system values at each execution step
* **Element Details Panel:** Complete details for assignments, decisions, record actions, and invocable actions
* **Error Scenarios:** Distinct presentations for unhandled faults, failed record operations, screen abandonment, validation failures
* **Performance Metrics:** Element execution time, total duration, governor limit consumption
* **Version Tracking:** Clear indication of which Flow version executed (critical for troubleshooting updates)

**The Result:** The Flow debugger allows element-by-element inspection of execution paths, variable states, and decision outcomes—making it straightforward to understand what happened during a Flow interview, even for complex multi-decision, multi-loop flows. By connecting log details back to the Flow Builder elements administrators recognize, Pharos makes declarative automation debugging as intuitive as the Flow building experience itself.
