Record-by-record editing wastes time. If you need to update 50 Opportunities or 20 Accounts at once, the UI forces you through click-for-each-record hell. Mass editing solves this. The Avonni Data Table gives you two ways to do it: a flow-based approach with a two-flow pattern, or a no-code Dynamic Components setup that works directly on Lightning Pages. Both let your users select multiple records and update them all in one shot.

The pain of record-by-record editing

Let's be concrete. You need to update the Stage on 50 opportunities from "Prospecting" to "Qualification." In traditional Salesforce:

1. Open the opportunity list view.
2. Click the first opportunity.
3. Find the Stage field.
4. Update it.
5. Save.
6. Go back to the list.
7. Click the next opportunity.
8. Repeat 48 more times.

That's 50 clicks, 50 page loads, 50 saves. At 10 seconds per record, that's nearly 8 minutes. For 50 records.

Now add the error factor. After clicking the 30th opportunity, mental fatigue sets in. Did you update this one already? Did you change the Stage or leave it blank? You might update the wrong field, or update only 40 records when you meant to update all 50. The time cost scales, but so does the error rate.

Multiply this across your org. If your team does bulk updates quarterly, that's lost productivity adding up to hours every year, multiplied by hundreds of users.

Salesforce's native mass edit limitations

Salesforce offers list view inline editing. You can select multiple records and edit them in-line, which is faster than the record-by-record approach. But there are limits:

• Limited to 200 records per edit session. If you need to update 500 accounts, you're doing this at least three times.
• Not all fields are editable inline. Formula fields, lookup fields, and multi-select picklists often can't be edited in-line.
• No rich validation or user guidance. You're just editing raw fields. There's no context, no warnings, no "are you sure?" checks.
• Can't combine with filters or conditions. You're editing everything selected, even if your criteria are complex.
• Limited formatting and user experience. The interface is functional but basic. No custom messages, no progress tracking, no visual feedback.

What about the other native options?

Data Loader: Powerful for admins, but not something you'd hand to an end user. It requires CSV exports, manual edits, and re-imports. Too many steps for a sales rep who just needs to update 20 opportunity stages.

Mass actions in Lightning: Limited to owner changes and a few other predefined operations. You can't mass-update custom fields or picklist values.

Mass editing via Avonni Data Table in Flow solves all of these limitations.

Why bulk editing in flows is better

A flow-based bulk edit gives you:

• No record limits. Edit 500, 5,000, or more records. The flow handles it.
• Edit any field. Formula? Lookup? Multi-select? All available.
• Rich validation and guidance. Show users hints, warnings, or calculated values before they save.
• Complex filtering. Use flow logic to show only the records that match your criteria.
• Customizable UX. Design the experience exactly as you want it. Add headers, instructions, progress indicators, success messages.
• Conditional field visibility. If a user updates Status to "Closed," show additional fields like Close Reason. Reactive components make this instant.

Understanding the performance implications

When you update 100 records, Salesforce writes 100 changes to the database. Here's what matters:

• Database commit time: Each record write takes a few milliseconds. 100 records = a few hundred milliseconds total. That's fine.
• Validation rules: If your object has complex validation rules, they fire on every record update. If a validation rule takes 50ms and you're updating 100 records, that's 5 seconds.
• Workflow rules and Process Builder: If you have workflows that trigger on updates, they'll fire 100 times. Keep them efficient.
• Triggers: Custom Apex triggers fire on bulk updates too. Optimize them or disable them for bulk operations.

Configuration tips for large record sets

Pagination for scanning

If you're editing 500 records, showing all 500 rows on one screen is overwhelming. Configure the Data Table to show 25 rows per page. Styling your Data Table for visual consistency also helps with large datasets.

Limit visible fields

Don't show every field. Show only the fields users need to edit plus context fields like Owner.

Filter before loading

Use the flow's filter logic to narrow the record set before the Data Table loads them. Smaller datasets load faster and are easier to edit.

Field validation during bulk edit

Required field validation

Mark fields as required in your Data Table configuration. If a user tries to save without filling a required field, the Data Table prevents save and shows an error message.

Pattern validation

For fields like email or phone, Avonni can validate patterns (e.g., "must be valid email"). Configure this in the Data Table column settings.

Custom validation logic

Before the update, run a flow decision. Example: "If Status = Closed AND Amount = 0, show an error message."

Real-world use cases for mass editing

Quarterly pipeline updates

Q1 is ending. All opportunities in "Proposal" stage need to be moved to "Negotiation" or "Closed." Users open a flow that shows all Proposal opportunities, select the ones they're responsible for, and bulk update in one go.

Mass status changes

A product launch happens. All accounts need to be marked as "Active" and assigned to a new territory. 200 accounts, one update, 30 seconds.

Support outage cleanup

A service outage creates 200 cases. Once it's resolved, someone needs to close them all and update the resolution notes. Bulk edit turns a 45-minute task into 2 minutes.

Data cleanup after imports

You imported 500 leads from a trade show, and the source field is blank on all of them. Select them, bulk edit, set source to "Dreamforce 2026," save. One operation instead of 500.

Territory reassignment

Your company reorganizes territories. All accounts in region "West" need to be reassigned to new owners. Use a flow with a bulk edit Data Table. Select 50 accounts, change owner, save. Done.

Contact cleanup

Your contact list has 1,000 leads marked with campaign source "Unknown." Bulk edit: filter for Unknown, update each to the correct source, save all at once.

Renewal status updates

Contract renewal season. 30 contracts entering renewal next quarter. Update them all at once: set Status to "Renewal in Progress," set Renewal Owner, set Renewal Date.

You'll need the Avonni Components Package installed.

The flow approach: two flows working together

Two flows work together:

1. Main Flow: Displays Salesforce records in an Avonni Data Table. Users select rows and click a "Bulk Edit" button.
2. Bulk Edit Flow: Opens as a modal. Loads only the selected records, makes them editable, saves changes, and closes.

Let's build it

Step 1: Build the main flow

• Add the Avonni Data Table: Drag it onto your screen.
• Connect data: Use "Query Data Source" to bind the table to a Salesforce object.
• Configure columns: Select the fields you want visible.

• Add a Bulk Edit button:
  • In the Data Table's Header section, click "Add Actions."
  • Name it "Bulk Edit" or "Mass Update."

Step 2: Build the bulk edit flow

• Store selected record IDs:
  • Create a Text collection variable (e.g., selectedRecordIds).
  • Enable "Allow Multiple Values."

• Format IDs for filtering:
  • Use the "Join Text Collection" Avonni Action to add commas between each ID.
  • Store output in a variable (e.g., recordIds).

• Build a filter formula:
  • Create a formula to filter the bulk edit Data Table to show only selected records:

  "Id IN ('" & {!recordIds} & "')"

• Add the bulk edit Data Table:
  • Place another Avonni Data Table on a new screen.
  • Configure it with "Query Data Source" and apply the filter formula.
  • Choose which fields are editable.
  • In "All Columns Settings," check "Display as Input" and "Editable."
  • Toggle "Hide Checkbox Column" and "Always Display Bottom Bar."

• Configure save and close actions:
  • Add "On Save" interactions to the bulk edit Data Table.
  • Include an "Update Records" action to persist changes.
  • Add "Finish Flow Navigation" to close the modal after saving.

Step 3: Connect the flows

• Return to the main flow.
• Configure the Bulk Edit button:
  • Add an interaction to the button.
  • Select "Open Flow Dialog."
  • Choose your Bulk Edit Flow.
  • Map "Selected Record Ids" output to selectedRecordIds variable.
  • Set dialog size to "Large."
  • On finish, select "Refresh Query" to reload the main table after bulk edit completes.

You've built mass editing. Users select records, click Bulk Edit, update them all at once, and the main table refreshes.

Related: Full flow tutorial.

The Dynamic Components alternative

If you're building on Lightning Pages instead of Flows, the Data Table's bulk edit works as a Dynamic Component too. The setup is simpler: no second flow, no modal configuration. The component handles everything built-in.

Your users select multiple rows, click one button, and a modal appears where they update the same fields across all selected records at once. Hit Save, and Salesforce updates every record. No Flow needed. No Apex. Nothing to maintain on the backend.

The setup comes down to three things:

1. Editable fields. In your data mappings, mark which columns should be editable. Only those fields show up in the bulk edit modal. This gives you complete control over what users can and can't change. If you want them to edit Stage and Close Date but not Amount, you set that here.

2. Row selection. Turn on multi-row selection in the table so users can pick which records to update. You can leave it open or cap it at a specific number. For data safety, you might want to limit selection to 50 records at a time, especially when dealing with fields that affect automation triggers.

3. A header action. Add a button in the table header (something like "Bulk Edit" or "Update Selected") and connect it to the built-in "Edit Selected Records" interaction. That button kicks off the whole process.

Once those three pieces are configured, the Data Table handles everything else: rendering the modal, showing the right fields, and pushing the mass update to Salesforce. Most admins have it running in under 15 minutes.

Full walkthrough with screenshots: Dynamic Components bulk edit tutorial.

Tips from teams already using bulk edit

Start with one high-volume use case. Don't try to make everything bulk-editable at once. Pick the scenario where your team wastes the most time on repetitive updates and build for that first. Opportunity stage changes and case status updates are the most common starting points.

Limit editable fields in the modal. Showing 15 fields in the bulk edit modal is overwhelming. Most teams expose 3-5 fields max. The fewer choices, the faster the user completes the action.

Add a confirmation step if the change triggers automation. If updating a field kicks off a process builder, approval, or flow, make sure your users know. You don't want someone accidentally bulk-updating 200 records and triggering 200 email notifications.

Use it alongside filters. The Data Table's built-in filtering lets users narrow down to exactly the records they need before selecting and editing. Filter by owner, date range, or status first, then bulk edit the filtered results.

Every click you eliminate is time back in your team's day. For anyone dealing with repetitive record updates, bulk edit turns a 30-minute task into 30 seconds.