For years, displaying on a screen the data returned by an Apex class had the same basic problem: the Data Table component in Screen Flows only accepted collections of standard objects as a source. If your logic lived in Apex, for example the response of an HTTP callout to an external API, you couldn't pass it straight to the table. You had to transform that data into records of an object, real or in memory, just to be able to display it.
The Winter '26 release of Salesforce changes that. We'll look at exactly what it adds, how it works and where its limits are. Everything below is based on official documentation, and the links to the sources are at the end.
What Winter '26 adds
The release note, titled "Display Complex Data with Apex-Defined Collection Support in Data Tables", confirms that Data Tables in Screen Flows now accept Apex-Defined collections as the Source Collection. Before, the source was limited to collections of standard objects. Now you can feed the table with the output of a Transform element or an HTTP callout, among other complex data.
In plain terms: the collection your Apex builds can go straight into the Data Table, without creating an intermediate object or saving temporary records just to display them.
A refresher: what Apex-Defined variables are
Apex-Defined variables have existed in Flow since the Summer '19 release. The idea is to let flows work with complex data structures, of the kind a web service call normally returns. A developer defines an Apex class that acts as a template, and the flow can handle those objects declaratively.
For that template to be visible from Flow, Salesforce documents two annotations:
@InvocableMethodidentifies the methods that can run as invocable actions, for example from a flow.@InvocableVariableidentifies the variables those invocable methods use inside a custom class. Each annotated variable is, in practice, one of the fields you'll be able to show as a column.
A generic example of the documented pattern:
public with sharing class CotizacionAction {
public class Cotizacion {
@InvocableVariable(label='Codigo' required=true)
public String codigo; // identifies each row, for example "USD"
@InvocableVariable(label='Moneda')
public String moneda;
@InvocableVariable(label='Valor')
public Decimal valor;
}
@InvocableMethod(label='Obtener cotizaciones' callout=true)
public static List<List<Cotizacion>> obtener() {
List<Cotizacion> filas = new List<Cotizacion>();
// The HTTP callout to the API and building the collection go here
return new List<List<Cotizacion>>{ filas };
}
}
The invocable method is static and public, and lives in an outer class. callout=true is used when the method makes HTTP calls. The double List is the Apex bulkification pattern: the method receives and returns a list per invocation, so to deliver a collection as output, the return type is a list of lists.
How to set it up in the Screen Flow
At a high level, the workflow is this:
In your Screen Flow, add an Apex action that runs the invocable method and returns the Apex-Defined collection.
On the screen, insert the Data Table component.
In Source Collection, select that Apex-Defined collection.
In the Configure Rows section, choose a field as the Unique Identifier, for example the code or an id.
Define the columns to display and, if you need it, enable Row Selection so the user can choose one or several rows.
For reference, the Data Table component for Screen Flows has existed since Winter '23, designed to display collections of records and allow selecting them, or for a simple display without selection.
Why the Unique Identifier matters
The Unique Identifier is not optional on a whim. Salesforce states that you must configure this field so that rows display and are selected correctly, and to avoid unpredictable behavior when duplicate values appear. It's the same concept as the keyField of the base component lightning-datatable: the unique identifier that ties each row to a record.
Scope and limits
It's worth being clear on one thing before planning your use case: this improvement is for displaying and selecting. The user can see the Apex-Defined collection in the table and, with Row Selection, choose rows to reuse later in the flow. Inline cell editing inside the Data Table is not part of this capability. If your scenario requires the user to edit the data right there, you'll have to solve it with a different approach.
Where you'll use it
Some scenarios where it fits well:
Displaying the response of an HTTP callout, such as quotes, stock or data from an external system, without persisting it in Salesforce.
Viewing the output of a Transform element or calculations resolved in Apex.
Building internal screens for quick review of complex data, without creating objects just to feed the view.
Wrap-up
This is not the flashiest feature of Winter '26, but it removes a concrete friction between the code layer and the interface. For teams that combine Apex with declarative automation, it's one of those improvements that simplify day-to-day work and shrink the transformation code that used to be mandatory.
If you work with Screen Flows and data that originates in Apex, it's worth trying it in a sandbox before the release reaches production.
Official Salesforce sources
Winter '26 release notes, "Display Complex Data with Apex-Defined Collection Support in Data Tables": https://help.salesforce.com/s/articleView?id=release-notes.rn_automate_flow_builder_apex_support_screen_flow.htm&language=en_US&release=258&type=5
Apex Developer Guide, @InvocableMethod annotation: https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_classes_annotation_InvocableMethod.htm
Apex Developer Guide, @InvocableVariable annotation: https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_classes_annotation_InvocableVariable.htm
Actions Developer Guide, Apex Actions: https://developer.salesforce.com/docs/atlas.en-us.api_action.meta/api_action/actions_obj_apex.htm
Apex Developer Guide, Data Types: https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/langCon_apex_data_types.htm
Lightning Component Reference, lightning-datatable base component: https://developer.salesforce.com/docs/component-library/bundle/lightning-datatable/documentation















