Skip to content

Build B2B platform

Internal tools and platforms that ship in weeks, not quarters

  • Senior engineers · IST + EST overlap
  • NDA on day 1
  • 24-hour reply

Tell us what you need fixed

Reply in 24 hours · NDA on day 1 · No spam.

Build B2B platform — done properly, by senior engineers

Krapton helps software companies build B2B platform foundations that survive enterprise procurement: SAML and OIDC single sign-on, SCIM user provisioning, tenant isolation, audit logs and the operational evidence a buyer’s security team asks for. Most teams reach this point when a large prospect sends a security questionnaire and the product, designed for self-serve signups, has no answer for per-tenant identity providers, deprovisioning or data residency. Retrofitting these late is hard because tenancy touches every table, query, cache key and background job. Krapton’s engineers begin with a tenancy decision record: shared schema with a tenant_id column and PostgreSQL row-level security, schema-per-tenant, or database-per-tenant for customers who require it, with the tradeoffs in migration effort and noisy-neighbor risk written down. SSO is integrated through a provider such as WorkOS, Auth0 or Keycloak, or implemented directly where that is the better fit, and SCIM endpoints keep users in sync with Okta and Microsoft Entra ID. Every privileged action lands in a tamper-evident audit log that tenants can export. Deliverables are the platform code, infrastructure as code, a tenant-onboarding runbook and draft answers for common security questionnaires.

What you're seeing

You're launching a B2B platform and need SSO, multi-tenant, audit logs, and enterprise-grade reliability.

Our approach

We build the B2B-grade stack: SSO (SAML / OIDC), tenant isolation, audit log, SLA-ready ops — without enterprise-bureaucracy speed.

Signs you need this build

  • Enterprise prospects stall at security review asking for SAML SSO, SCIM and audit log exports.
  • Each new customer needs a manual database script or a separate deployment to be onboarded.
  • A missing tenant filter in one query has exposed, or nearly exposed, another customer’s records.
  • One large tenant’s import or report slows the application for every other customer on shared infrastructure.
  • Removing a departed employee from the identity provider does not revoke their access to your product.

What ships in the box

  1. The data model was built for single users, with tenancy added later as an afterthought column.
  2. Tenant scoping is enforced in application code by convention, with no database-level policy as backup.
  3. Authentication uses passwords or social login only, with no per-tenant identity provider configuration.
  4. Background jobs, caches and search indexes are not partitioned or keyed by tenant.
  5. There are no per-tenant rate limits, queues or quotas, so heavy workloads compete for resources.

Concrete deliverables, no fluff

Every engagement ends with measurable, documented outcomes — no black-box agency reports.

  • Discovery + tight scope doc
  • Pixel-perfect UI on a modern stack
  • Auth, RBAC, audit log out of the box
  • CI/CD, staging, and observability wired up

What changes after we ship

  • Enterprise SSO and SCIM provisioning

    Each tenant connects its own Okta, Entra ID or Google Workspace through SAML or OIDC, and SCIM keeps users and groups in sync, including automatic deactivation when someone leaves.

  • Tenant isolation enforced in layers

    Tenant context is set once per request, carried into PostgreSQL row-level security policies, cache keys, queue payloads and search filters, and covered by cross-tenant access tests in CI.

  • Exportable audit log for tenants

    Logins, permission changes, data exports and admin actions are recorded with actor, tenant, IP and timestamp in an append-only store, with export to the customer’s SIEM when contracts require it.

  • Operations ready for an SLA

    Health checks, per-tenant metrics, alerting, backups with tested restores and a documented incident process give you the evidence to commit to an uptime SLA without guessing.

From brief to shipped fix

A transparent, low-risk process — a senior engineer reads your brief personally, and nothing starts until you approve a written plan and price.

  1. 01Day 0–1

    Diagnose

    A senior engineer reviews your brief, reproduces the issue, and pinpoints the real root cause — not the symptom — before any code is touched.

  2. 02Within 24h

    Scoped plan & quote

    You get a written plan to build B2B Platform, a firm timeline, and a fixed quote. Nothing starts until you approve it — no surprise invoices.

  3. 034–12 weeks

    Ship the fix

    We implement on a branch and open a pull request you review, working to your code-review standards on your repo — never a black box.

  4. 04On delivery

    Verify & hand off

    We verify on staging and production, share before/after evidence where it applies, and leave you a short hand-off note so the fix sticks.

Situations we handle

  • Vertical SaaS moving upmarket

    A product that sold to small teams now faces enterprise deals requiring SSO, role hierarchies and contractual data handling, and needs those added without freezing feature work for a quarter.

  • Partner and distributor platforms

    Manufacturers or wholesalers giving dealers a shared platform where each partner organization sees only its own orders, pricing and users, with parent-child account hierarchies and delegated administration.

  • Regulated buyers needing data separation

    Customers in finance or healthcare who require dedicated databases or region-specific hosting, served by a hybrid model where most tenants share infrastructure and a few run isolated stacks from the same codebase.

Why teams hand this task to Krapton

  • Senior engineers only

    Your brief is read and handled by a senior engineer — no junior hand-off, no sales-rep filter in between.

  • Root cause, not a patch

    We reproduce and fix the underlying cause, then add a guard so the same class of issue does not quietly return.

  • Your repo, your standards

    Every change lands as a pull request you review, on your repository, following your existing review process.

  • NDA on day one

    Confidentiality and IP are covered before we look at a single line of code. All work stays in your accounts.

  • Fixed quote up front

    You approve a written plan and price before work starts. If scope changes, we re-quote in writing — no surprise invoices.

  • Proof, where it applies

    Performance, SEO and reliability work ships with before/after evidence so the result is measurable, not anecdotal.

Three ways to engage

No retainer required. Pick the model that matches the work — pricing for this task starts from $500, with a fixed quote before anything starts.

  • Per task

    Most popular

    One clearly-scoped fix at a fixed price. Best when you know exactly what is broken and want it handled end to end.

    • Fixed quote up front
    • One PR, reviewed by you
    • No retainer required
  • Hourly

    Pay only for the hours worked. Best for diagnostics, audits, or exploratory work where the scope is still emerging.

    • Weekly timesheets
    • Pay for what you use
    • No minimum commitment
  • Per sprint

    A focused 1–2 week sprint when the work is bigger than one fix but smaller than a full project.

    • 1–2 week blocks
    • Clear sprint goal
    • Scale up or stop anytime

Industry-standard stack, no proprietary lock-in

  • Next.js
  • Node.js
  • PostgreSQL
  • Tailwind CSS
  • Vercel

Build B2B platform — your questions, answered

How much does it cost to build B2B Platform?

Pricing starts from $500 and depends on the scope we find during the diagnostic. You get a fixed, written quote before any work begins — most engagements like this run 4–12 weeks.

How long does it take to build B2B Platform?

Typically 4–12 weeks for a focused engagement. After a short diagnostic we commit to a firm timeline so you know exactly what to expect.

How should we build B2B platform tenancy: shared database or one database per customer?

Start with a shared database and row-level security unless a contract demands otherwise. A shared schema with a tenant_id on every table is the simplest to migrate, monitor and back up. Database-per-tenant gives the strongest isolation and per-customer restores but multiplies migrations and connection pools. Many platforms run shared tenancy by default and offer dedicated databases as an enterprise tier, which the architecture should allow from day one.

Should SSO be built in-house or bought from an identity provider?

For most teams, buying is the faster and safer route. SAML has many edge cases, including clock skew, certificate rotation, IdP-initiated login and attribute mapping, and each enterprise customer configures them differently. Managed services such as WorkOS or Auth0, or a self-hosted Keycloak, absorb that variation, and WorkOS also handles SCIM directory sync. Building directly with a maintained SAML library makes sense when vendor cost, data residency or control requirements outweigh the maintenance burden.

Can tenant isolation be added to an existing product with live customers?

Yes, usually in stages rather than one cutover. A tenant_id is added and backfilled table by table, queries are routed through a tenant-aware data layer, and PostgreSQL row-level security is switched on only after query logs show every path already sets tenant context. Cross-tenant tests are written before each step, so any query that still ignores tenant context fails in CI instead of in production.

Let's get this off your plate

Send a 60-second brief on Build B2B Platform and a senior engineer replies within 24 hours with a plan and a fixed quote. NDA on day one, no retainer required.