Portage, by GTM Cloud · Capture · Early access
See what a bulk data change will do before it does it
Portage is a Salesforce data import tool for CSV and Excel files. Every row is checked against your live field rules before anything saves, and updates show the old value next to the new one.
You know this one
It’s late in the week. Someone from sales sends a spreadsheet with 4,000 rows and a message that says “can you just load this in?”
You can. You also know what “just” is hiding. A column that’s almost a picklist value. Dates in two formats. A mapping that looks right until Monday, when a rep asks why every account in the West region now has the same phone number.
A loader does what the file says. Nobody finds out what the file said until afterwards.
A Salesforce data import tool that shows its work first
Portage puts a preview between the file and your data. You build a template once from the object’s live fields. After that, anyone you choose can upload a CSV or Excel file, map the columns, and run a check.
Every row is validated against the real field rules: required, type, picklist, length. Nothing is saved. If it’s an update, you see the current value and the new value side by side, so a wrong mapping is obvious on the screen and not in next month’s report.
When the rows are right, you import. If your process needs a second pair of eyes, there’s an approval step for that.
See it first. Take it back. Keep the receipt.
| Preview | Undo | Prove |
|---|---|---|
| Every row validated, and before and after values for updates, before anything is saved. | Export only the rows that failed, fix them, and load them back into the same job. | Approvals, an import debrief and a job history for every load. |
What you get
Mistakes caught before they exist
Validation runs against your live field rules and saves nothing. You fix the file, not the fallout.
Before and after, side by side
For updates, every changed field shows what it holds now and what it’s about to hold. The wrong-column mistake has nowhere to hide.
Self-service that stays inside the lines
You build the template. The business runs the wizard. They can only write data that passes validation, on the fields you chose.
Templates that keep up with your org
Templates are built from the object’s live schema, so a renamed or changed field doesn’t leave you with a quietly broken mapping.
Sign-off with a trail
Optional approval for a template, for each import job, or both. Add a checklist and a minimum share of rows that must pass before an import can run.
Big files, handled in the background
Large files are processed in chunks that stay inside platform limits, and move to the background on their own. A job pipeline shows where each one is.
How it works
- Build a template. Pick an object and its fields, set how records are matched, and decide whether approval is needed.
- Upload a file. Choose the template, upload a CSV or Excel file, and map the columns.
- Validate and review. Check every row, read the errors in plain words, and compare before and after for updates.
- Import. Send it for approval if your process asks for one, then import. Export the results, or reload the corrected rows.
Two readers, two reasons
If you’re the admin
Build a template once and hand the wizard to the people who own the data. The spreadsheet stops landing on your desk, and a bad file stops landing in production.
If you’re the one signing off
Bulk changes are where data quality is won or lost. Portage puts a check, an optional approval and a record around every one, without adding a tool outside Salesforce or another place for your data to live.
Today, and with Portage
| Today | With Portage |
|---|---|
| Files go to the admin, who runs a loader and hopes | The people who own the data run their own imports, in a wizard |
| A bad mapping overwrites records, and the first clue is a complaint | Validate first, read the before and after, then import |
| No record of who approved a bulk change | Approvals, checklists and a debrief are part of the job |
| A large load fails halfway with no clear reason | Row-level status and errors, background processing, and a reload |
Where it’s strong, and what to know first
We’d rather you find the limits here than after you install.
Where Portage is strong
- Nothing is saved until every row has passed your live field rules
- Old and new values on screen for every update
- Business users run their own loads, inside limits you set
- Optional approval for templates and for each job
- Failed rows are exported, fixed and reloaded into the same job, with no starting over
Good to know before you install
- Portage loads files a person brings to it. It doesn’t connect to other systems and isn’t a replacement for an integration.
- Updates find records by Salesforce Id, so an update file needs the Id column.
- Files are CSV or Excel (.xlsx).
- Approvals run on Flow, which needs to be available in your org.
Questions people ask
How do I import a CSV into Salesforce without Data Loader?
With Portage, you upload the CSV or Excel file in a four-step wizard inside Salesforce. An admin builds the template once, then anyone with access can map columns, validate every row against the live field rules, review the changes, and import. There’s nothing to install on a desktop.
Can I preview a bulk update in Salesforce before it saves?
Yes. Portage validates every row and saves nothing until you choose to import. For updates, it shows the current value and the new value side by side for each changed field, so you can catch a wrong mapping before it touches a record.
We already have tools for loading data. Why this one?
A loader writes what the file says. Portage checks each row against the field’s type, required setting, picklist values and length first, shows what an update would change, and saves nothing until you say so.
Can business users really be trusted with it?
They work inside a template you built, in a locked-down wizard. Add approval for the template, for each job, or both, and set a minimum share of rows that must pass before an import can run.
What happens with a large file?
Processing is chunked to stay inside platform limits and moves to the background by itself for large files. A job pipeline shows where it is, row by row.
Does our data leave Salesforce?
No. Portage is native. The file is read, validated and imported inside your org, by the person running it, with their access.
Works well with
- Sluice: after a big load, find and merge the duplicates it created, with an undo.
- Wake: keep a field history of what each import changed, beyond the native limits.
- Stow: the records are in. Now collect the documents that belong on them.
Portage is part of the Capture stage of the lead-to-renewal map. Planning a migration or a big cleanup? Our data foundation service does the heavy lifting with you. Every app installs by itself. None needs another.
Built on the platform
- Native to Salesforce. Nothing runs outside your org.
- Validation comes from the platform’s own field rules, so it follows them as they change.
- Three permission sets: Admin, Approver and User.
- In-app guides for admins and users, in English, German, Spanish, French (Canada) and Portuguese (Brazil).
Bring the file you’re nervous about
Ask for early access and a walk-through using one of your own templates. Run validation and read every error before a single record is written.