PROPELOO

SAAS / PRODUCT ENGINEERING

Build software products designed to serve thousands of customers simultaneously.

PROPELOO engineers SaaS products — from multi-tenant architecture and billing infrastructure to API design, usage metering and the observability systems that let you debug production issues without touching customer data. SaaS architecture is revenue architecture.

The architecture of a SaaS product determines your unit economics as much as your pricing model.

Multi-tenancy design determines infrastructure cost per customer. Billing system determines how fast you can launch new pricing models. API design determines enterprise integration speed. Observability determines how fast you can debug production issues without seeing customer data. These are architecture decisions that become business constraints — and they are almost impossible to change once customers are live. PROPELOO designs SaaS architecture for the business you are building, not just the product you are shipping today.

What sits underneath a production SaaS product.

A SaaS product is not a web app with a subscription form. It is a multi-tenant system, a billing engine, an API product and an operational platform — each with distinct engineering requirements.

System Layers

  • Tenant Isolation Layer: Row-level security or schema isolation, cross-tenant data access prevention, tenant configuration management
  • API & Integration Layer: REST / GraphQL APIs, API versioning, rate limiting per tenant, webhook delivery, OpenAPI documentation
  • Billing & Metering Layer: Stripe integration, subscription lifecycle, usage metering, invoice generation, dunning, upgrade/downgrade flows
  • Application & Business Logic: Core product features, background jobs, notifications, workflow automation, third-party integrations
  • Observability & Ops Layer: Structured logging, distributed tracing, per-tenant metrics, alerting, admin tooling, audit trail

Core Technical Capabilities

  • Multi-tenant Architecture Design

    Tenant isolation model design — shared schema with row-level security vs schema-per-tenant — with tenant context propagation, cross-tenant access prevention and infrastructure cost-per-tenant modeling.

  • API-first Product Engineering

    REST or GraphQL API design with OpenAPI documentation, semantic versioning, backward compatibility guarantees, per-tenant API keys, rate limiting and a developer experience that enables enterprise integration.

  • Billing & Subscription Infrastructure

    Stripe-based billing with subscription lifecycle management (trial, active, past due, cancelled), seat-based and usage-based billing, proration, invoice generation, dunning flows and pricing model flexibility.

  • Usage Metering & Limits

    Real-time usage tracking per tenant, configurable plan limits, overage billing, usage-based pricing meters, fair-use enforcement and usage analytics dashboards for product and sales teams.

  • Admin & Operations Dashboard

    Internal admin tooling for tenant management, support lookups, billing overrides, feature flag management, system health monitoring and operational runbooks.

  • Self-serve Onboarding

    Frictionless self-serve onboarding — email/OAuth signup, product tour, initial configuration flow, first-value milestone tracking and activation analytics to optimise trial-to-paid conversion.

How we think about SaaS product engineering.

SaaS architecture is revenue architecture. The database design, tenant isolation model and billing infrastructure determine your margins as much as your pricing page.

  • Multi-tenancy is a day-one decision

    Retrofitting multi-tenancy onto a single-tenant data model is the most expensive SaaS architecture refactor. Row-level security, schema isolation and tenant context propagation must be designed before the first migration.

    Axiom:

  • Billing infrastructure is a product

    The ability to launch a new pricing tier, add a usage-based component or grandfather existing customers depends entirely on the billing system you built. Billing infrastructure determines pricing agility.

    Axiom:

  • API design is enterprise sales

    Enterprise customers evaluate API quality before purchasing. Clean API design, comprehensive documentation, consistent versioning and webhook delivery reliability directly affect enterprise deal close rates.

    Axiom:

  • Observability enables velocity

    The faster you can debug a production issue without accessing customer data, the faster you ship. Structured logging with tenant context, distributed tracing and anomaly alerting are engineering infrastructure for product velocity.

    Axiom:

The decisions that define a SaaS architecture.

These choices compound. Getting them right early costs a week. Getting them wrong becomes a multi-quarter refactor.

  • Shared schema vs schema-per-tenant vs database-per-tenant

    Impact: Shared schema is cost-efficient but requires rigorous access control at every query. Schema-per-tenant makes migrations complex. Database-per-tenant is justified only for strict compliance requirements or very high per-customer revenue.

    • Shared schema with RLS (Row-Level Security) — lowest infrastructure cost, highest engineering care required for isolation
    • Schema-per-tenant — strong isolation, complex migrations (must run per schema), moderate infra overhead
    • Database-per-tenant — strongest isolation, highest infra cost, enterprise compliance advantage
  • Usage-based vs seat-based billing

    Impact: Usage-based billing requires real-time metering infrastructure. Changing billing models after customers are live requires migration logic, grandfather pricing rules and significant customer communication.

    • Seat-based — predictable for customers, easy to implement, misaligns cost with value for variable usage
    • Usage-based (metered) — aligns cost with value, more complex billing implementation, hard to predict for customers
    • Hybrid — base platform fee + usage overage — predictable baseline with usage alignment
  • REST vs GraphQL API

    Impact: REST is the universal choice for external-facing SaaS APIs. GraphQL adds flexibility but makes API versioning, caching and per-field authorisation more complex.

    • REST — universal, well-understood, over-fetching for complex queries
    • GraphQL — flexible client queries, single endpoint, complex caching and authorisation per field
    • tRPC — end-to-end type safety, TypeScript monorepo only, no external consumers
  • Synchronous vs asynchronous job processing

    Impact: Any operation that might take more than 3 seconds should be asynchronous. Synchronous API calls that block on long operations create timeout failures and poor user experience.

    • Synchronous — simple, blocks request thread, poor for operations >3 seconds
    • Background jobs (Sidekiq, BullMQ, SQS) — non-blocking, reliable retry, monitoring overhead
    • Event-driven (Kafka/EventBridge) — fully decoupled, eventual consistency, higher complexity
  • Feature flag strategy

    Impact: Feature flags decouple deployment from release, enabling dark launches, gradual rollouts and per-tenant feature gating. The infrastructure investment pays off by the 10th feature that needs controlled rollout.

    • No feature flags — simplest, all users see same product, dangerous for risky deployments
    • In-code flags with config — simple, limited targeting
    • Feature flag service (LaunchDarkly, Statsig) — per-tenant targeting, gradual rollout, A/B testing, higher cost
    • In-house flag system — full control, build investment
  • Hard vs soft multi-tenancy isolation

    Impact: Hard isolation is required for regulated enterprise customers (healthcare, finance, government). Most SaaS products start with soft isolation and offer hard isolation as an enterprise tier upsell.

    • Hard isolation — separate compute per tenant, highest infra cost, strongest compliance posture
    • Soft isolation — shared compute with logical separation, cost-efficient, requires rigorous access control
    • Hybrid — shared compute by default, dedicated compute option for enterprise tier

What SaaS product engineering becomes.

  • B2B SaaS Platform

    Multi-tenant B2B product with team management, role-based access, subscription billing, API access and enterprise onboarding flows for SMB to mid-market customers.

  • Developer Tools Platform

    Developer-facing SaaS with API key management, usage metering, tiered rate limiting, comprehensive OpenAPI documentation and a developer portal.

  • Analytics SaaS

    Data analytics platform with multi-tenant data isolation, usage-based pricing on data volume, dashboard builder, scheduled reports and data export infrastructure.

  • Vertical Industry SaaS

    Industry-specific SaaS product with domain data model, regulatory compliance features, integration with industry-standard systems and vertical-specific reporting.

  • Marketplace SaaS

    Two-sided SaaS marketplace with buyer/seller accounts, listing management, transaction processing, trust infrastructure and platform fee mechanics.

  • Enterprise SaaS with SSO & SCIM

    Enterprise-ready SaaS with SAML/OIDC SSO, SCIM provisioning/deprovisioning, custom roles, audit logging, data residency options and SOC 2 compliance documentation.

The SaaS engineering stack.

Technology selection follows the product requirements, team expertise and the compliance posture required for the target customer segment.

  • Backend

    Stack: Node.js / TypeScript, Go, Python, PostgreSQL, Redis, BullMQ / Sidekiq

  • Frontend

    Stack: React / Next.js, TypeScript, TailwindCSS, shadcn/ui, Tanstack Query, Zustand

  • Billing & Payments

    Stack: Stripe Subscriptions, Stripe Billing (metered), Stripe Customer Portal, Usage Metering API

  • Auth & Identity

    Stack: Auth0 / Clerk, SAML / OIDC SSO, SCIM Provisioning, JWT, API Key Management, MFA

  • Infrastructure

    Stack: AWS (ECS / Lambda), Docker, Kubernetes, Terraform, GitHub Actions, Datadog

  • Feature Flags & Ops

    Stack: LaunchDarkly / Statsig, Sentry, OpenTelemetry, Structured Logging, Audit Trail DB, Internal Admin Panel

SaaS security is multi-tenant security. Every vulnerability potentially affects every customer.

A security failure in a SaaS product is not one customer's problem. It is every customer's problem — and a company-defining event.

  • Tenant Data Isolation

    Row-level security misconfiguration, missing tenant context in queries and incorrect caching can leak one tenant's data to another. Every data access path must be tested for cross-tenant leakage. RLS policies must be verified at the database layer, not only in application code.

  • SSO SAML & OIDC Security

    XML signature bypass, SAML assertion manipulation and OIDC nonce attacks are known SSO vulnerabilities that allow authentication bypass. SAML and OIDC integrations must be reviewed against known attack patterns before any enterprise customer onboards.

  • API Rate Limiting

    SaaS APIs without per-tenant rate limiting can be consumed disproportionately by one tenant, degrading service for all others. Tenant-level rate limits, quota enforcement and cost-per-request metering protect the platform from both abuse and unintentional overconsumption.

  • SOC 2 Readiness

    Enterprise customers require SOC 2 Type II reports before signing. SOC 2 controls — access management, change management, incident response, availability monitoring and vendor risk — must be implemented and evidenced before the audit. Building to SOC 2 from day one is faster than a gap remediation project.

  • GDPR Data Residency

    EU customers require data residency within the EU. Architecture decisions — database region, backup location, log forwarding destinations and third-party processor selection — all affect GDPR compliance. Data processing agreements and deletion request workflows must be designed into the product.

  • Audit Logging Per Tenant

    Enterprise customers require audit logs of all actions within their tenant — who accessed what, when, with what result. Immutable per-tenant audit trails, log retention policies compliant with customer requirements and self-service audit log export are required for enterprise sales.

From SaaS idea to enterprise-ready product.

  1. 01. Architecture & Tenant Model

    Tenant isolation model selection, data model design, billing infrastructure selection, API contract design and compliance surface mapping.

  2. 02. Core Infrastructure

    Authentication, multi-tenancy enforcement, database setup with RLS, API skeleton with rate limiting and monitoring instrumentation.

  3. 03. Billing & Subscription

    Stripe integration, subscription lifecycle management, usage metering, plan management, upgrade/downgrade flows and customer portal.

  4. 04. Product Feature Engineering

    Core product features delivered in fortnightly sprints with feature flags, staged rollout capability and production monitoring from day one.

  5. 05. API & Developer Experience

    Public API development, OpenAPI documentation, API key management, webhook infrastructure, rate limiting and developer portal.

  6. 06. Enterprise Features

    SSO/SAML/OIDC, SCIM provisioning, audit logging, data residency configuration, admin controls and SOC 2 control documentation.

  7. 07. Launch & Scale

    Production deployment, observability dashboards, billing go-live, self-serve onboarding activation, SLA monitoring and post-launch optimisation.

Frequently Asked Questions

What is multi-tenancy and why does it matter for SaaS architecture?

Multi-tenancy means a single deployed system serves multiple customers (tenants), with data isolation between them. There are three main approaches: shared schema (all customers in the same tables, filtered by tenant_id), schema-per-tenant (separate schema per customer in the same database), and database-per-tenant (separate database per customer). The choice determines infrastructure cost per customer, migration complexity, isolation strength and compliance posture. Shared schema is cost-efficient but requires rigorous access control. Database-per-tenant is expensive but offers the strongest isolation.

How do we architect billing for a SaaS product?

Stripe is the standard starting point — Stripe Subscriptions for seat-based billing, Stripe Billing with meters for usage-based pricing. The billing architecture must handle: subscription lifecycle (trial, active, past due, cancelled, paused), proration when customers upgrade or downgrade mid-cycle, usage metering with real-time or end-of-period aggregation, dunning (automatic retry and customer notification for failed payments), and pricing model flexibility so you can change pricing tiers without a rebuild.

How do we implement SSO for enterprise customers?

Enterprise SSO uses SAML 2.0 or OIDC. SAML is the older standard, widely supported by corporate identity providers (Okta, Azure AD, Google Workspace). OIDC is the modern standard. Most enterprise SaaS products support both. Implementation: tenant-level IdP configuration, SAML assertion validation (Audience restriction, signature verification), JIT (just-in-time) user provisioning on first login, attribute mapping from IdP claims to your user model, and SCIM for automated user provisioning and deprovisioning.

When should we implement usage-based pricing vs seats?

Seat-based pricing is simpler to implement and easier for customers to predict. Usage-based pricing aligns cost with value — customers pay more as they get more value. Choose usage-based when: your value metric is clearly tied to a measurable action (API calls, records processed, emails sent), your target customers have highly variable usage patterns, or you want to remove adoption friction for new customers. Usage-based requires real-time metering infrastructure and more complex billing logic.

What does SOC 2 compliance require technically?

SOC 2 Type II tests controls over a period (typically 6-12 months). Technical controls required: access management (least privilege, MFA, access reviews), change management (code review, deployment controls, audit trail), availability monitoring (uptime SLA evidence, incident management), logical access controls (authentication, authorisation, session management), data protection (encryption at rest and transit, backup and recovery), and vendor risk management. Building these controls into the architecture from day one is faster than retrofitting after a gap analysis.

How do we handle API versioning in a SaaS product?

URL versioning (/v1, /v2) is the most common approach for SaaS APIs — explicit, easy to route, and allows breaking changes with a migration period. The policy must include: what constitutes a breaking change (removing fields, changing types, removing endpoints), minimum deprecation notice period (typically 6-12 months), sunset headers on deprecated endpoints, and a clear migration guide for each breaking change. Maintain previous versions long enough that enterprise customers with slow procurement cycles can upgrade.

How do we build webhook delivery that enterprise customers can rely on?

Reliable webhook delivery requires: persistent event queue (not in-memory), at-least-once delivery semantics with idempotency keys, retry with exponential backoff on failure (typically 3-5 retries over 24 hours), per-endpoint delivery logs accessible to customers, configurable delivery timeout, HMAC signature verification payload so customers can validate authenticity, and event ordering guarantees where required. Webhook delivery failures that silently lose events are an enterprise deal-breaker.

How do we approach GDPR compliance for a SaaS product?

GDPR compliance for SaaS requires: a data processing agreement (DPA) template for customer execution, data residency controls (EU customer data stays in EU regions), right-to-deletion implementation that removes all PII across all data stores (including backups and logs), data portability (export of customer data on request), consent management for any direct marketing, and a data breach notification procedure. Technical implementation: tenant-level data residency configuration, deletion workflows that cascade across all storage systems, and audit trails of data access.

What is SCIM provisioning and which customers need it?

SCIM (System for Cross-domain Identity Management) allows enterprise customers to automatically provision and deprovision users in your SaaS product from their identity provider (Okta, Azure AD). When a new employee joins, they are automatically added to your product. When they leave, they are deprovisioned — preventing orphaned accounts. Enterprise security teams often require SCIM before signing. Implementation requires a /scim/v2 endpoint supporting User and Group resources with CRUD operations, mapped to your user management model.

How long does a SaaS product take to build?

A production SaaS product with multi-tenancy, billing, authentication, core features, API and basic observability takes 16-28 weeks from architecture to launch. Enterprise features (SSO, SCIM, audit logs, SOC 2 controls) add 6-10 weeks. Products with complex data models, custom workflow builders or marketplace components take longer. We deliver in two-week sprint cycles with staging environment releases at each milestone.