Manage RFQs & Purchase Orders in a Salesforce Customer Portal
Turning a request for a quote into a purchase order should take minutes. If a quote sits untouched for three days, or a PO lands in Salesforce with the wrong line item, the breakdown isn't in your CRM. It's the manual handoff between your buyer's inbox and your Salesforce records. Same story when a customer emails to ask where their order stands and someone has to go dig it up.
That handoff is expensive. In fact, 53% of financial and operational teams report that data errors and discrepancies remain a major process challenge, according to the Institute of Financial Operations & Leadership (IFOL). Salesforce isn't the problem here. Your data model, pricing, and approvals already live in it. The problem is the rekeying between the buyer and the CRM, and it's fixable without replacing anything.
Here's why doing this inside a portal is harder than it looks. Managing RFQs and purchase orders isn't a display problem. It's a two-way write path. A read-only portal can show a buyer their past orders, but an RFQ has to flow in the other direction. The buyer submits it. The portal creates a real Salesforce record, which triggers your internal quote approval, and an approved quote becomes a purchase order. Then the status syncs back to the buyer, without anyone rekeying a thing. Most portals stall at the first write. They mirror Salesforce data outward but can't capture a transaction inward, so the manual entry and its error rate never actually go away. This guide walks the full loop inside a Salesforce Customer Portal, sometimes called a Salesforce client portal, step by step.
Key Stats
What You Need Before You Start
This guide assumes a working Salesforce org and a portal layer on top of it. Before Step 1, confirm you have each of these in place. If one is missing, the step that depends on it will fail quietly.
Salesforce edition with your quoting objects defined. You need the quote object enabled and an object for purchase orders, either the standard Order object or a custom PO object. RFQs usually map to a custom RFQ object, a case, or an opportunity, depending on how your team already works.
A portal user permission set or profile. External users need their own permission set with object and field access scoped to what a buyer should see. Don't reuse an internal profile.
The CRMJetty Salesforce Customer Portal installed and connected to the org, with the no-code builder available. This is the layer that captures RFQs and writes them back.
An existing Salesforce approval process or workflow for quotes. The portal triggers this, it doesn't replace it, so the approval logic has to exist first.
A pricing source. Salesforce CPQ, a price book, or a manual quoting step. The portal captures the RFQ, but the price still comes from your Salesforce setup.
Once these are ready, you can build the loop.
Step 1: Map Your RFQ, Quote, and Purchase Order Objects
Start by deciding which Salesforce object each stage of the process writes to. This mapping is the backbone of everything that follows, and getting it wrong here is what forces a rebuild later. A Salesforce Customer Portal reads and writes any standard or custom object, so your job is to be deliberate about which one does what.
Walk through the three records a buyer touches and decide who writes each one.
Record | Salesforce object | Portal action | Who writes it |
RFQ | RFQ custom object, Case, or Opportunity | Buyer submits a form | Buyer, through the portal |
Quote | Quote (standard) | Internal pricing and approval | Your team, in Salesforce |
Purchase Order | Order (standard) or custom PO object | Buyer views and confirms | Created on approval, synced to the portal |
The detail that matters most is field-level security. External users must not see internal cost fields, margin, or private notes, even when those fields sit on the same object. Set field-level security on the portal permission set first. Then add a sharing set so each buyer sees only their own records.
Verification: open the portal object list and confirm the RFQ, Quote, and Order objects appear. Create one test RFQ record and check that it shows in Salesforce with the buyer's account attached, and nothing internal exposed.
Pro tip: Model your sharing rules before you build a single form. If a buyer can load another company's purchase order because the sharing set was an afterthought, that's a data-exposure incident, not a bug. Fix access at the object level first, then design the interface on top of it.
Step 2: Build the RFQ Submission Form in the Portal
With objects mapped, build the intake form buyers use to submit an RFQ. Use the no-code drag-and-drop builder to place the fields, or describe the form in plain language and let the AI Form Generator lay it out for you. Either way, the form binds to the RFQ object you chose in Step 1.
Include the fields a buyer actually needs: product or SKU, quantity, required-by date, and delivery location, plus an attachments field for specs or drawings. Add line items if buyers request multiple products in one RFQ. Keep required fields to the minimum that lets your team price the request without a follow-up email.
The point of this step is to write. When a buyer hits submit, the Salesforce Customer Portal from CRMJetty creates a real RFQ record in Salesforce through real-time two-way sync. No export. No overnight batch. No rep copying the request into the CRM by hand.
Verification: submit a test RFQ from a portal login. Confirm the record appears in Salesforce within seconds, mapped to the right account and contact, with every field populated as entered.
Step 3: Route Submitted RFQs for Internal Quote Approval
A submitted RFQ is just a record until something acts on it. In this step you connect the portal submission to the approval process that already lives in Salesforce, so a new RFQ launches internal review and pricing automatically.
The approval logic stays native. Your Salesforce approval process or workflow rule fires when the RFQ record is created, routes it to the right approver, and applies your pricing. The portal's job is narrower: trigger that process on submission, then reflect its state back to the buyer. Configure the portal to show a clear status, Submitted, Under Review, or Quoted, so the buyer is never left guessing and never has to email to ask.
This is where the two-way path earns its keep. The buyer sees movement. Your team works the quote inside Salesforce with full context. And no one rekeys anything between the two.
Verification: submit a test RFQ and confirm the Salesforce approval process launches and assigns an approver. Check that the portal now shows the request as Under Review for that buyer.
Step 4: Convert an Approved Quote into a Purchase Order
Once a quote is approved, it becomes a purchase order the buyer can act on. Generate the Quote in Salesforce, using CPQ or your price book, then convert the approved quote into an Order or custom PO record. That record is what the portal surfaces to the buyer for confirmation.
Be clear about where pricing comes from. The portal captures the RFQ and displays the resulting purchase order, but it doesn't invent prices. Your Salesforce configuration produces the numbers, whether that's CPQ or a manual quoting step. The portal moves them, it doesn't calculate them.
A question that comes up on almost every implementation call is who actually approves the conversion. The answer depends on your existing Salesforce approval chain, and that's the point: the portal doesn't add a second approval layer to maintain. If a sales manager signs off quotes over a threshold today, that same rule governs the portal-submitted RFQ. You're not rebuilding governance you already have.
Running RFQ-to-PO conversion by hand is exactly where the errors and the delays creep in. If you want to see the approved-quote-to-PO step configured against your own objects, request a demo and walk it through with your admin.
Verification: approve a test quote and confirm a purchase order record is created and linked to the original RFQ. Check that the buyer sees the PO in the portal with the correct line items and totals.
Pro tip: Link the PO record back to its originating RFQ with a lookup field. When a buyer questions a line item six weeks later, that link lets support trace the purchase order to the exact request and quote in one click, instead of reconstructing the thread from email.
Step 5: Give Buyers Real-Time PO Status and Order History
The final step closes the loop: buyers see live purchase order status and their full order history without contacting anyone. This is the self-service payoff that drives real organizational velocity; according to global benchmark data from Deloitte, companies that successfully automate and orchestrate their intake management see 27% faster transaction cycle times.
Configure the portal dashboard to display each purchase order with its current status, line items, quantities, and expected dates, pulled live from Salesforce. Map the Salesforce status field to a buyer-friendly label, so a stage like Fulfillment shows as In production. Because sync runs both ways, a status change your team makes in Salesforce appears on the buyer's dashboard without a manual refresh or a re-export.
Keep role-based access tight here. A buyer should see their own orders and history, and nothing else, which is what the sharing set from Step 1 enforces. This is also the difference between a true Salesforce client portal and a static status page. The data is live, scoped to the buyer, and tied to the same records your team works from.
Verification: change a purchase order's status in Salesforce and confirm the buyer's portal view updates to match. Log in as a second buyer and confirm they can't see the first buyer's orders.
Common Mistakes to Avoid
Most RFQ and purchase order portals fail in predictable ways. These are the ones worth checking for before you go live.
Building a read-only portal. If the portal displays purchase orders but can't capture an RFQ that writes back to Salesforce, you've moved the email thread behind a login. The rekeying, and its discrepancy rate, stays exactly where it was.
Skipping field-level security. Exposing internal cost or margin fields to external users on a shared object is a common and serious slip. Lock fields down on the portal permission set, not just the page layout.
Forgetting the sharing set. Without it, buyers can load records that aren't theirs. Object access without record-level sharing is an exposure waiting to happen.
Expecting the portal to auto-price. The portal captures and routes the RFQ. If you have no CPQ and no quoting step, there's nothing to generate the price. Decide your pricing source before you build.
Leaving the approval process unwired. If the portal creates RFQ records but nothing triggers your Salesforce approval, requests pile up, stay unrouted, and buyers wait. Connect the trigger in Step 3, don't assume it.
Mapping status one way. If the buyer's status field only reads at login and never re-syncs, the dashboard goes stale and buyers start emailing again. Confirm the sync runs both directions.
Conclusion
You now have the full loop. A buyer submits an RFQ, the portal writes it to Salesforce, and your approval process prices it. The approved quote becomes a purchase order, and the status syncs back, all without a rep rekeying a single field. The work was never about displaying records. It was about the right path and the approvals underneath it, which is exactly where read-only portals give up.
Start with the object mapping and the sharing model, because every later step depends on them. Once those are solid, the forms, approvals, and status views fall into place quickly. For teams that want this running on flat-fee pricing with real-time two-way Salesforce sync and no-code configuration, CRMJetty's Salesforce Customer Portal is built to handle the RFQ-to-purchase-order loop end to end.
Sources
Institute of Financial Operations & Leadership (IFOL), Accounts Payable Automation Trends 2025: acarp-edu.org (PDF)
Gartner, Survey Finds 67% of B2B Buyers Prefer a Rep-Free Experience (2026): gartner.com
Deloitte, 2025 Global Chief Procurement Officer Survey: deloitte.com Original Blog: https://www.crmjetty.com/blog/manage-rfqs-purchase-orders-salesforce-customer-portal/
Comments