B2B web portal development: Types, integration and cost

front end technologies-1

In B2B portal development, the ERP and CRM integration usually sets cost and timeline more than the interface does. The right portal type, build route and first-release scope depend on how complex your pricing, approval chains and back-office systems are, and how long the portal has to stay flexible.

What a B2B portal is and what to decide first

A B2B portal is a login-gated application where buyers order through account hierarchies and role-based access control, with customer-specific pricing and stock pulled from the ERP. A storefront sells one catalog at one price to anonymous visitors. A portal must call the ERP at checkout, so the first decision is what happens when that call times out.

Netguru designs and builds custom web portals, marketplaces, and system integrations, and we recommend settling the ERP integration contract before the interface, because price, credit, and approval logic follow from it.

That order fits negotiated pricing and multi-level approvals; a list-price catalog with one buyer per account needs only a storefront. Where the portal is part of a wider online sales channel, our B2B commerce platform development work covers that storefront layer too.

Which B2B portal type fits your business?

The right B2B portal type depends on who logs in and which job they must finish without calling you: reordering, registering a deal, confirming a purchase order, buying from several sellers, or administering seats. Every type below runs on account hierarchies and role-based access control, so the choice changes the workflows built on top of the identity model.

The six types side by side:

Type Who logs in Job they do Pick it when
Customer portal Buyer's purchasers, approvers, accounts payable Reorder, track shipments, download invoices, open tickets Repeat accounts have contract prices and order history that sit in the ERP
Dealer and partner portal Resellers, distributors, agents Register deals, view tiered price lists, pull marketing assets Revenue flows through third parties and you need channel visibility
Vendor or supplier portal Your suppliers Confirm purchase orders, upload invoices and certificates You chase confirmations by email and spreadsheet
Ecommerce portal Buyers, often via procurement systems Self-serve checkout against negotiated catalogs Most orders are low-touch repeats, and large buyers need punch-out (cXML)
B2B marketplace Buyers and independent sellers Discover, compare and transact across sellers You do not own the supply and can recruit both sides
Admin portal A client's HR, operations or IT administrators Manage users, seats and usage reports Organizations buy your product and their admins would otherwise email support

A B2B marketplace carries the most risk of the six, because seller onboarding, payouts and catalog quality must work before buyers see value. We recommend it as a first build only when one side of the market is already committed. Otherwise, start with a customer or dealer and partner portal and add third-party sellers later.

Booksy had that committed side: beauty and wellness businesses already ran their bookings on its app. Netguru built the B2B marketplace where those businesses buy supplies, with checkout, payments, inventory management and product search moved to Elasticsearch, so buyers search and order from a 30,000+ product catalog in one flow.

An admin portal is the cheapest type to justify when support tickets come from client administrators. When Babbel moved into B2B, Netguru built an admin dashboard where client administrators create groups inside their organisation, give members admin access and see whether and how their teams use the app.

The types overlap, and most projects combine two. A customer portal often gains checkout and becomes an ecommerce portal. If you are unsure, build for the audience that generates the most support contacts today.

That audience shows where the portal pays back first, and its ERP integration will be reused by every later type.

Which features does a B2B customer portal need at launch?

At launch, a B2B customer portal needs account hierarchies with role-based access control, customer-specific pricing, single sign-on, and a catalog fed by a product information management (PIM) system. Order history and reorder sit on top. Other screens can wait until those four are trustworthy.

The day-one scope and what to defer:

Capability Day one Phase two
Account hierarchies and role-based access control Parent and child accounts, buyer, approver and admin roles Customer-defined custom roles, delegated administration
Customer-specific pricing Price lists and contract prices read from the ERP Quote negotiation, rebate tracking
Single sign-on SAML or OpenID Connect against the customer's identity provider Automated user provisioning
Catalog PIM-fed product data, search, stock visibility Configurators, AI-assisted search
Orders History, reorder, invoice download cXML punch-out
Support Contact form, order status Ticketing

Deep account hierarchies are the first thing to break under load. A buyer at the tenth level of a parent-child tree inherits permissions from every level above, and resolving that on each request slows every page.

We recommend precomputing effective permissions per user, caching them, and invalidating on role or hierarchy change. The OWASP Application Security Verification Standard gives you access-control requirements to test that cache against.

The second failure is a SaaS portal that cannot model a customer's approval chain. If an order needs sign-off from a site manager and then a finance lead, a platform with only flat roles forces workarounds such as shared logins or email approvals outside the system. Before you sign, model your most complicated real customer's approval chain in the vendor's sandbox.

Our decision rule is to leave ticketing, punch-out and AI features to phase two, for three reasons:

  • Punch-out needs clean catalog and price mapping first.
  • Ticketing needs a support process the portal can mirror.
  • AI features need structured content and permission boundaries to draw on.

That third dependency decides whether an AI feature is useful. At NewGlobe, a GenAI system built on the client's existing content templates, spreadsheets and exemplar guides cut teacher guide creation from four hours to 45 seconds.

How should a B2B portal integrate with ERP and CRM?

ERP integration and CRM integration for a B2B portal work best through integration middleware, either an iPaaS or an API gateway with a message queue, with a sync pattern chosen per data type: synchronous for price and credit, events for stock and order status, batch for master data.

Hub and spoke diagram with integration middleware at the center, connected to an ERP, a CRM, product master data and EDI and punch-out. EDI and punch-out come in phase two, through an iPaaS connector or a dedicated translator.

Most ERPs were not built to answer web traffic, so the pattern decides what buyers see when the ERP is slow or offline.

Data type Pattern Latency tolerance Failure behavior
Customer-specific price Synchronous call with cached price list Seconds at checkout Serve cached price until expiry, then block or mark price pending
Stock Event-driven, cached in portal Seconds to minutes Show last known value with an "as of" timestamp, replay missed events
Order submission Accept into outbox, deliver asynchronously Instant to buyer, minutes to ERP Retry from outbox with idempotency key
Order status Event-driven, polling as reconciliation Minutes Show last known status, reconcile on a schedule
Credit limit Synchronous check Seconds at checkout Hold the order as "pending credit review"
Accounts, contacts, hierarchies (CRM) Batch or change events Hours Next run corrects drift, alert on failed runs

The hard case is an ERP price call that times out at checkout. We recommend serving contract prices from a cached price list with an explicit expiry, and blocking the order once the cache expires or the item is quote-priced. If your contracts carry rebates or regulated pricing, skip the cache and accept the order with the price marked pending confirmation.

Order submission needs two safeguards. Generate an idempotency key per cart submission and write the order and an outbox row in one database transaction. A worker then delivers the order to the ERP, which deduplicates on the key. A buyer who double-clicks during an outage creates one order, not two.

Each system exposes the hooks for this. SAP S/4HANA publishes OData APIs for business partners and sales orders. Microsoft Dynamics 365 supports Dataverse webhooks that post change events to an HTTP endpoint. Salesforce offers Change Data Capture for record changes, which suits CRM-owned account data.

Middleware earns its cost when more than one backend is involved. An adapter layer maps each system's quirks into one internal contract, so the portal never learns a vendor's field names, auth scheme, or error codes. Swapping an ERP, or adding a second one after an acquisition, then touches the adapter and leaves portal screens alone.

Where middleware belongs: iPaaS, API gateway or direct calls

Use direct calls for one ERP with a modern API, and add an iPaaS from roughly three connected systems or when the ERP lacks usable APIs. Treat EDI and punch-out catalogs as phase two.

The trade-offs side by side:

Situation Middleware choice
One ERP with a released API, such as SAP S/4HANA OData services Direct calls from the portal backend, with caching for price and stock
ERP, CRM and a third system, or an ERP with no usable API (older on-premises, file-based) iPaaS for mapping, retries and monitoring
Many dealers or partners calling your own APIs API gateway for authentication, throttling and versioning
Buyers who require cXML or OCI punch-out, or EDI Phase two, through an iPaaS connector or a dedicated translator

An API gateway and an iPaaS solve different problems. The gateway protects and routes traffic to APIs you own, while the iPaaS translates between systems that disagree on data shape.

Vinted GO shows the second pattern: Netguru built adapters that connect its unified shipping system to carriers that each expose a distinct API, so every new carrier plugs into one internal contract.

Our view is that punch-out waits unless a signed anchor buyer demands it at launch. In that case, move it into phase one and budget for per-buyer testing.

Build custom, buy SaaS or use a platform?

Build custom when approval chains, pricing logic or ERP integration exceed what a SaaS model supports, buy SaaS for standard catalog ordering, and pick a platform when you need depth without a full build.

Our assessment of the three routes, side by side:

Route Flexibility Integration depth Time to market TCO Exit cost
Custom build Highest: any approval or pricing model Any ERP, CRM or legacy system, built to spec Longest Highest upfront, then a standing team You own code and data; exit means a rewrite when the stack ages
SaaS B2B commerce (BigCommerce B2B Edition) Configuration inside the vendor's model Prebuilt connectors and public APIs; the vendor sets the ceiling Shortest Subscription that grows with usage and add-ons Highest hidden cost: business logic lives in vendor configuration
Platform (Adobe Commerce, Saleor, Pimcore, Salesforce, Dynamics 365) Extensible within the framework Deep, through APIs and extensions Middle License or hosting plus an integration partner Moderate: extension code is coupled to the framework

The platforms differ in what they fit:

  • Adobe Commerce: company accounts, shared catalogs and quotes ship with its B2B features, which suits distributors who want those built in and can run a heavy stack.
  • Saleor: an open-source, API-first headless commerce engine for teams that build their own storefront. Our Saleor vs SAP Commerce comparison covers that trade-off.
  • Pimcore: fits when product data, channels and enrichment workflows are the hard problem.
  • Salesforce: fits when the CRM already holds accounts, contracts and entitlements.
  • Microsoft Dynamics 365: fits when it is already the ERP and finance system of record.

We recommend custom if any of these holds:

  1. Approval chains branch on order value, cost center and budget, beyond role-based thresholds.
  2. Prices must come from the ERP per line item in real time, which a nightly price-list import cannot serve.
  3. The ERP has no usable API, or the portal must unify many external systems.

Migrating off a SaaS portal costs more than the data export suggests. Order history, company records and price lists leave through bulk APIs. Approval rules, saved requisition lists, SSO configuration and ERP connectors must be rebuilt in the new system. Buyers also have to relearn their ordering workflow.

To limit that cost, keep pricing and approval logic in the ERP or your middleware, and write bulk-export rights for companies, users and price lists into the contract. Where the SaaS model fits your process, this tends to keep exit manageable. Where it doesn't, custom or platform work usually costs less than a forced migration in year three.

Headless platforms and custom builds both let you add AI assistants, workflow engines or new front ends later without replacing the core. SaaS limits that to what the vendor exposes. Getting that flexibility right starts with the underlying design, and commerce architecture consulting can help you decide which components to keep, replace or expose before you commit to a route.

What are the steps in B2B portal development?

B2B portal development runs in five steps: discovery, UX and architecture, build and integrate, test, and launch with data migration. Each step ends in a named output, and the next step starts only after that output passes a check.

Pipeline diagram of the five ordered steps of B2B portal development: discovery, UX and architecture, build and integrate, test, and launch and migration. Each step ends in a named output that must pass a check before the next starts.

Step Deliverable Check before moving on
Discovery Scoped backlog, user roles, account hierarchy model, inventory of ERP and CRM endpoints Every backlog item maps to a user role and to the system that owns its data
UX and architecture Clickable prototype, role-based access control matrix, SSO decision (SAML or OpenID Connect), integration pattern with data ownership per system Sales and operations users walk through the prototype, and the matrix covers every role from discovery
Build and integrate Working increments each sprint, ERP integration adapters with idempotent order submission, search index Resubmitting the same order does not create a duplicate in the ERP
Test Report covering ERP-offline behavior (queued orders, cached price lists), load tests at peak ordering volume, security checks against OWASP ASVS Queued orders sync once the ERP returns, and load tests run at peak volume
Launch and migration Migrated accounts, price lists and order history, cutover and rollback plan, monitoring dashboards Rollback has been rehearsed, and migrated record counts reconcile with the source

A skipped check moves its cost downstream. If the account hierarchy is still disputed after discovery, pricing and approval rules tend to be rebuilt mid-build. If ERP-offline behavior is untested, the first outage becomes the test.

Search belongs in the build step too: a catalog in the tens of thousands of products needs a search engine with load tests at peak traffic before launch.

Staff the project with five roles:

  • An executive sponsor who decides budget and priority conflicts.
  • A product owner who takes part in every weekly sprint.
  • An IT architect who knows the existing systems and integrations.
  • QA specialists for functional and performance testing.
  • Stakeholders from sales, operations, and finance.

Infrastructure setup runs in parallel with feature work from the first sprint, so you'll need cloud environments on AWS, Azure, or GCP, containers with Docker and Kubernetes, CI/CD pipelines for automated testing and deployment, and observability tooling. A SaaS route skips most of this, but the integration and testing steps still apply.

How do you migrate buyers off a legacy portal or extranet?

Migrate buyers off a legacy portal or extranet in phases, by account cohort, with both portals running in parallel until pricing and permissions reconcile. Most failures come from account data, not from the new front end.

Pipeline diagram of a phased cutover from a legacy portal. Stages in order: deduplicate and map accounts, price-diff samples per cohort, federate single sign-on, then move pilot, low-volume and largest cohorts.

Failure mode Typical cause Early sign
Duplicate buyer accounts Legacy logins keyed on email, so one buyer holds several accounts One email maps to multiple ERP customer IDs after import
Lost price-list assignments Customer-specific pricing held in extranet custom fields, not in the new account hierarchy Test orders price at list
SSO and password friction Legacy password hashes can't be reused, so every buyer re-registers Reset requests and tickets spike at first login
Big-bang cutover All accounts switch on one date with no fallback No rollback path

A phased cutover addresses each of these:

  1. Deduplicate and map accounts to the new account hierarchy and role-based access control before any import, keyed on the ERP customer ID, not email.
  2. Price a sample of historical orders in both portals per cohort and diff the results.
  3. Federate single sign-on through SAML or OpenID Connect for buyers with a corporate identity provider, and send invite links to the rest. NIST SP 800-63 covers authenticator and federation assurance levels.
  4. Move a pilot cohort first, then low-volume accounts, then the largest. Keep the legacy portal read-only until the last cohort has placed orders.

With only a few dozen accounts, a weekend big-bang cutover can be cheaper than running two portals.

What drives B2B portal development cost and timeline?

ERP integration depth is the first driver to scope, with customer-specific pricing and account hierarchies close behind. Score a project on five drivers before asking any vendor for a quote. We give no total price or timeline range here, because scope varies too widely for a benchmark to hold.

The worksheet below is our own. The scoring is illustrative: 1 point for the low-end answer, 3 for the high-end answer, 2 for anything in between.

Driver Low-end answer (1 point) High-end answer (3 points)
Integration count ERP is the only system behind the portal ERP plus CRM, PIM, payments and carrier or logistics APIs, each with its own mapping and retry logic
ERP type and API quality Documented REST or OData API with stable versioning Legacy ERP with batch files or no stable API, which needs integration middleware (iPaaS or API gateway) and a caching layer
Role and pricing complexity Flat roles and one public price list Account hierarchies with approval chains, role-based access control, and customer-specific pricing resolved per request
Compliance scope Standard authentication in one region SSO through SAML or OpenID Connect, a target OWASP ASVS level, and GDPR data residency
Migration and MVP scope Greenfield launch with ordering and invoices only Legacy accounts to reconcile, plus returns, quoting and punch-out in launch scope

As an illustrative reading, a total of 5-7 points fits a narrow MVP. A total of 8-11 points calls for a phased plan with the ERP integration first. A total of 12-15 points means the integration and pricing work should be estimated separately from the front end before any budget is committed.

A hypothetical example shows how to use it. Assume a portal that connects the ERP and a payment gateway (2), runs on a legacy ERP with batch files (3), needs approval chains and customer-specific pricing (3), uses SSO in one region (2), and must reconcile legacy accounts at launch (2). That totals 12, so the integration and pricing work gets its own estimate.

Integration count multiplies effort, because each added system brings its own mapping, error handling and test surface.

Pricing is the second place estimates slip. If the ERP cannot return a buyer's price list quickly, the portal usually needs a pricing cache with invalidation rules, and that work rarely appears in an initial quote. Confirm the ERP's real response times in week one.

Ongoing costs sit outside the build estimate: hosting, third-party licenses, support retainers and continuous feature development all add to total cost of ownership, so budget for them from the first estimate. Our web app development cost breakdown shows how these line items fit the overall budget.

Securing the portal and choosing a development partner

Secure a B2B portal by testing it against the OWASP Application Security Verification Standard (ASVS), then choose a development partner who answers six questions with evidence. Single sign-on (SAML, OpenID Connect), role-based access control over account hierarchies, and ERP integration carry most of the exposure.

Buyers sign in through their own identity provider, so require SAML and OpenID Connect, with assurance levels mapped to NIST SP 800-63. Check four more things:

  • Role checks run server-side at every account node.
  • Tenant isolation is tested, so one buyer never sees another's price lists or orders.
  • Audit logs record price and permission changes.
  • The data residency plan matches your GDPR obligations.

The six-point partner checklist:

  1. ERP references: a live integration with your ERP (SAP, Dynamics 365), plus how they handle retries and idempotency on order writes.
  2. Identity and security practice: target ASVS level, recent penetration-test summaries, per-customer SSO onboarding.
  3. Engagement model: how scope changes are priced under fixed-scope and dedicated-team contracts.
  4. Post-launch support: response times, and who owns ERP API version changes.
  5. Discovery approach: a discovery phase that ends in an integration map and an account hierarchy model before any estimate.
  6. Exit terms: ownership of code, infrastructure and documentation, and a handover plan.

Portals change shape as the product matures, which is why points 3 and 6 deserve the most scrutiny. Compare shortlisted vendors on our portal development companies page.

B2B portal FAQ

What is a B2B portal?

A B2B portal is a secure web application where a company's customers, dealers, or partners log in to order, see customer-specific pricing, and manage their accounts. It reads from the seller's ERP and CRM, so stock and prices stay current. A B2B marketplace differs: a third party runs it for many sellers.

What are the top 10 B2B portals in the USA?

No independent ranking of the top 10 B2B portals in the USA exists, because most are private systems behind a login. The visible ones are B2B marketplaces such as Amazon Business, Faire, and ThomasNet. A manufacturer's own dealer and partner portal rarely appears on such lists, so shortlist by portal type.

What is the best B2B portal?

The best B2B portal is the one that fits who logs in and which systems it must read from. A dealer ordering against negotiated price lists needs ERP integration and account hierarchies, while a buyer comparing many suppliers needs a B2B marketplace. Match the type first, then check single sign-on (SAML, OpenID Connect) and integration middleware.

Scope your B2B portal with an engineering team

Scoping a B2B portal works best as a short discovery workshop with the engineers who will build it.

We recommend bringing three inputs: the ERP integration points for prices, stock, and orders; the account hierarchies and roles you need to support; and your position on headless commerce versus a packaged storefront.

Our software development teams can turn those inputs into a scoped backlog, an integration approach, and an estimate you can compare against SaaS and platform options.

Send your ERP, main user types and target launch date through our project estimate form, and we will propose a workshop agenda.

We're Netguru

At Netguru we specialize in designing, building, shipping and scaling beautiful, usable products with blazing-fast efficiency.

Let's talk business