What Custom Web Design, Ecommerce, and SaaS Builds Actually Cost in 2026
Most pricing articles for custom websites are either pulled from thin air or skewed by the agency publishing them. The honest answer to “what does this cost” depends on five things: what type of build it is (marketing site vs. ecommerce vs. SaaS application), how many integrations it needs, how custom the UX is, what infrastructure it runs on, and how much of the work is on the agency vs. your team. This is the breakdown we actually use when scoping web design, ecommerce, and SaaS builds in 2026.
Key takeaways
- Build type sets the floor; integrations set the ceiling. A 10-page marketing site is a different cost universe than a custom SaaS application or a B2B ecommerce store with ERP sync. Across all three categories, the integrations are usually the largest variable cost — not the design or the page count.
- The cheapest build is usually the most expensive long-term. $5k template builds on shared hosting accumulate technical debt fast — plugin conflicts, performance issues, security patches — and tend to need a full rebuild within 18–24 months. Budget for the architecture you’ll need at month 24, not month 1.
- Hourly rates vary 10× by geography, but quality varies less. US senior developers run $150–$250/hr. Eastern Europe runs $50–$90/hr. India runs $25–$50/hr. The skill ceiling is similar at the senior end; the variance is in junior-to-mid talent and project management.
- Ongoing costs are 30–50% of the build cost annually. Hosting, plugins/SaaS subscriptions, maintenance, security, performance monitoring, and incremental feature work — plan for this from day one, not after launch.
The three categories of website build, and why they price differently
Custom website work in 2026 splits into three categories with genuinely different cost structures. Conflating them is one of the main reasons agency quotes feel arbitrary.
Marketing & brand websites
The classic deliverable: a corporate site, marketing site, or content-led site that exists to convert visitors into leads. Usually 8–40 pages, content-managed via a CMS, integrated with a CRM and analytics, optimized for SEO and Core Web Vitals. The work is mostly design, frontend implementation, content, and technical SEO. Backend complexity is minimal — the CMS handles it. This is the bulk of “web design agency” work.
Ecommerce stores
The deliverable is a transactional storefront: catalog, cart, checkout, payment, shipping, tax, fulfillment integration, customer accounts, post-purchase flows. Built on Shopify, WooCommerce, BigCommerce, or a custom headless stack. Cost driver is the catalog and integration complexity — a 50-SKU store with a B2B configurator and ERP sync costs more than a 5,000-SKU store with simple variants. Operational complexity post-launch is significantly higher than a marketing site.
SaaS & custom web applications
The deliverable is software, not a website: user authentication, application state, multi-tenant data, subscription billing, custom dashboards, real-time interactions, API integrations. The codebase is typically Next.js / React on the frontend, Node / Python / Go on the backend, with PostgreSQL and Redis as the data layer. Cost driver is the engineering team’s time, not design hours. SaaS builds compound in cost more aggressively than the other two categories because every new feature interacts with every existing one.
Pricing tiers within each category
Marketing & brand websites
Tier 1: Template / theme-driven ($3k–$15k). WordPress with a premium theme, Webflow on a template, or Framer / Wix / Squarespace customized. 5–15 pages, basic forms, Google Analytics, simple CRM hookup (HubSpot or Mailchimp). Timeline 4–8 weeks. The right tier for early-stage startups, local services, or any business where the website is supporting rather than driving sales.
Tier 2: Custom-designed marketing site ($15k–$50k). Bespoke design, custom CMS implementation (WordPress + ACF, Sanity + Next.js, Webflow custom build), proper component system, performance optimization to hit green Core Web Vitals, real CRM integration with deduplication and lead scoring, content collections (blog, case studies, resources), Schema.org markup, and at least basic A/B testing infrastructure. Timeline 8–16 weeks. Where most growth-stage B2B brands actually land. The cost driver here is the design system and the CMS configuration — not page count.
Tier 3: Premium / enterprise marketing site ($50k–$150k+). Headless architecture (Sanity / Storyblok + Next.js), interactive elements (custom animations, scroll-driven storytelling, 3D / WebGL where genuinely useful), multi-language with proper hreflang setup, advanced personalization, deep marketing-stack integrations (Salesforce + Marketo / Hubspot + Segment), accessibility audited to WCAG AA, and the kind of design polish that takes weeks of design iteration. Timeline 4–6 months. The right tier when the website is a primary brand asset and conversion lever — typically B2B SaaS over $20M ARR or DTC brands where brand experience is the moat.
Ecommerce stores
Tier 1: Template-driven storefront ($3k–$15k). Shopify on a premium theme or WooCommerce on a block theme. Catalog under 200 SKUs, default checkout, basic shipping rules, no custom integrations beyond Klaviyo / Google Analytics. Timeline 4–8 weeks. Right for brands validating product-market fit; trap is outgrowing this tier within 12–18 months.
Tier 2: Custom-designed storefront ($15k–$60k). Custom theme on Shopify or WooCommerce, real integrations (CRM, ERP feed, review platform, advanced shipping via ShipStation or similar), catalog up to 5,000 SKUs. Timeline 8–16 weeks. Where most growth-stage ecommerce brands land. Cost driver: the integrations and bespoke UX, not the page count.
Tier 3: Headless or custom application ($60k–$250k). Headless WooCommerce or Shopify Plus with a Next.js / Hydrogen frontend, or fully custom on Medusa / Saleor. Product configurators, complex variant trees, B2B pricing rules, multi-region storefronts, multi-currency with localized payment methods, ERP integration with NetSuite or SAP, advanced search via Algolia. Timeline 4–6 months. Most stores at this tier do $5M–$50M GMV.
Tier 4: Enterprise platform ($250k–$1M+). Multi-region deployment, SOC 2 / PCI compliance, deep ERP integration with bidirectional sync, B2B with punch-out integration to Coupa / Ariba, custom AI for search and recommendations, real DevOps with multi-region CDN and disaster recovery. Timeline 6–18 months. $50M+ GMV or regulated industries.
SaaS & custom web applications
Tier 1: MVP build ($15k–$60k). Single-workflow validation. Auth, a functional dashboard, core feature loop, payment integration via Stripe, basic admin panel. Built using SaaS starter kits or boilerplates (Supabase + Next.js, Clerk + Vercel, etc.) which cut redundant scaffolding work by 60–80%. Timeline 2–4 months. The point is shipping fast to validate demand, not building a polished product. The trap: founders who treat the MVP like a production product and try to scope all the eventual features in. The MVP that ships in 8 weeks teaches you more than the perfect spec that ships in 16.
Tier 2: Production-ready SaaS ($40k–$150k). Architecture hardened for paying customers. Comprehensive QA, scalable database, role-based access control, a real admin / customer-success dashboard, billing logic that handles edge cases (proration, plan changes, dunning, refunds), usage tracking and quota enforcement if the pricing is metered, audit logs, real error tracking and observability. Timeline 6–12 months. This is where most successful seed-stage SaaS products land before raising Series A. Cost driver: the engineering team — typically a senior full-stack lead, two mid-level engineers, a designer, and a part-time DevOps person, plus QA.
Tier 3: Enterprise SaaS ($300k–$1M+). SOC 2 Type II compliance, advanced RBAC with custom roles and permissions per customer, SSO via SAML and OIDC, audit logging that satisfies enterprise security reviews, multi-region deployment with data residency options for EU customers, advanced API with rate limiting and tiered quotas, customer-specific feature flags, deep integration with the customer’s tooling (Slack, Salesforce, Jira, etc.). Timeline 12–24 months of focused work. The astronomical cost is driven by compliance, the security review process, and the team size required to maintain a product at this complexity — dedicated DevOps, dedicated security, dedicated product engineering teams, plus the full GTM org.
Where the budget actually goes (regardless of category)
For a Tier 2 build in any of the three categories, the rough split:
- Discovery and strategy (5–10%): User research, technical scoping, sitemap or feature spec, integration mapping. Founders often try to skip this; the rework cost when scope changes mid-build is several times what discovery costs upfront. A 2-week discovery on a 16-week project pays back many times over.
- UX and visual design (15–20%): Wireframes, high-fidelity mockups, design system, component library, prototypes. The pattern that fails: skipping the design system and letting individual components emerge ad-hoc. By month 4 the product has six button styles and three navigation patterns. Investing 3–5 days in a design system early is one of the highest-ROI moves in any build.
- Frontend development (25–35%): Component implementation, responsive breakpoints, accessibility, performance optimization, SEO foundations. For SaaS builds, this is where most engineering hours land — dashboards, data visualization, real-time UI states. The cost driver: how many custom components you need vs. how much you can use existing libraries (Tailwind UI, shadcn/ui, Hydrogen for Shopify, Material UI for SaaS).
- Backend / integrations (20–30%): The most variable line item. A simple marketing site: 5%. A SaaS with real-time collaboration, custom auth, and four third-party integrations: 40%+. Each major integration is typically 1–3 weeks of engineering depending on complexity and how clean the third-party API is.
- QA and launch (8–12%): Cross-browser testing, real-device mobile testing, accessibility audit, performance audit, payment integration testing including 3DS edge cases, security review, load testing. The cost of skipping this: discovering at launch that Apple Pay doesn’t work on Safari iOS or that your authentication flow breaks under concurrent load, and losing two weeks of revenue.
- Project management (10–15%): Sprint planning, stakeholder communication, scope management, change orders, documentation. Some agencies bury this in the hourly rate; some line-item it. Either way it’s real work and not optional on a multi-month build.
The architecture choice and total cost of ownership
The most consequential cost decision happens at the architecture layer. The same project on three different stacks can have wildly different total costs over a three-year horizon.
Monolithic CMS (WordPress with classic theme)
Lowest upfront cost ($3k–$30k for most projects). Familiar to non-technical teams. Massive plugin ecosystem. The trade-offs are real: tight coupling between backend and frontend means every plugin update is a regression risk; performance degrades as plugins accumulate; security maintenance is ongoing because outdated plugins remain the leading WordPress breach vector. Right for content-led sites where the team values editorial flexibility over performance ceiling, and where the engineering team isn’t going to invest heavily in custom development.
Headless / decoupled (Next.js with WordPress, Sanity, or Storyblok backend)
Higher upfront cost ($15k–$80k for marketing sites, $60k–$250k for ecommerce). The frontend is a custom JavaScript application; the backend is a pure content / data API. Trade-offs: edge delivery and sub-second TTFB; near-zero attack surface on the public web (no admin panel exposed); content team retains familiar editorial UX. Costs more upfront, less long-term — security maintenance drops to near zero, hosting on Vercel / Cloudflare scales horizontally without intervention. Right for sites that need real performance, sites with engineering capacity to maintain a JS frontend, or sites where the content team is shipping pages frequently and benefits from a clean editorial UX.
Custom application (Next.js / Remix / Phoenix LiveView, Postgres, Redis, custom backend)
Highest upfront cost ($60k–$1M+). Mandatory for SaaS products and complex ecommerce. The flexibility is total — every part of the stack is yours. The maintenance is also total. Engineering team size for a serious custom app is typically 3–10 people including frontend, backend, DevOps, design, and QA. Right when the product can’t be built on existing platforms, or when the platform tax of SaaS-tier ecommerce platforms exceeds the cost of running custom infrastructure.
| Architecture | Initial build | 3-year maintenance | Performance | Security overhead |
|---|---|---|---|---|
| Monolithic WordPress | Low ($3k–$30k) | High ($10k–$30k/yr) | Average without aggressive caching | Ongoing plugin patching |
| Headless (Next.js + CMS) | Moderate ($15k–$80k+) | Low ($3k–$15k/yr) | Excellent (edge delivery) | Minimal exposed surface |
| Custom application | High ($60k–$1M+) | Variable ($30k–$300k+/yr) | Tunable, depends on team | Owned end-to-end |
What integrations actually cost
Integrations are the most consistently underestimated line item across all three build categories. Honest 2026 numbers:
- Payment gateway (Stripe, Adyen, Braintree): $1k–$5k for basic; $5k–$15k with 3DS configuration, multi-currency, regional payment methods (iDEAL, Bancontact, Klarna), or custom checkout flows.
- CRM sync (HubSpot, Salesforce): $3k–$15k for basic customer/lead sync; more for custom field mapping, lead scoring, or marketing automation triggers.
- ERP integration (NetSuite, SAP, Microsoft Dynamics): $15k–$60k+. Variance is enormous. NetSuite is generally cheaper to integrate than SAP. Tools like Celigo or Boomi reduce custom dev cost but add monthly platform fees.
- Authentication (Auth0, Clerk, custom SSO): $2k–$15k. Custom SSO via SAML for enterprise SaaS sales is often $10k–$25k of engineering work because every customer’s IdP behaves slightly differently.
- Search (Algolia, Typesense, Elasticsearch): $3k–$15k integration plus monthly platform fees ($100–$2k/mo based on volume).
- Analytics & product analytics (GA4, Mixpanel, Amplitude, Segment): $2k–$10k. Segment as the routing layer is worth its license cost on any project with 3+ destinations.
- Email/marketing automation (Klaviyo, Customer.io, Loops): $1k–$5k integration. Klaviyo is the ecommerce default for a reason; Customer.io and Loops compete strongly for SaaS lifecycle marketing.
- Subscription billing (Stripe Billing, Recurly, Chargebee): $5k–$30k integration. Custom on Stripe Billing is more work than off-the-shelf Recurly / Chargebee but gives full control.
- Reviews / social proof (Yotpo, Okendo, Junip, Loox): $1k–$5k integration plus $30–$500/mo platform fees.
- Help & support (Intercom, Front, Zendesk, Crisp): $1k–$5k for basic; more if you want deep customer-context sync from your application data.
The platform tax: ongoing costs by stack
WordPress / WooCommerce
Platform itself is free. Real costs: managed hosting at $50–$500/mo (Kinsta, WP Engine, Cloudways), premium plugins and themes at $1k–$5k/year, Cloudflare or similar CDN at $20–$200/mo, security tooling, backup solution. Total platform spend usually $5k–$25k/year for a serious WordPress or WooCommerce site before agency cost.
Shopify and Shopify Plus
Shopify Basic at $39/mo to Plus starting at roughly $2,500/mo with revenue-tiered scaling. Transaction fees of 0.5–2% if you don’t use Shopify Payments, falling to 0.15% on Plus. App Store apps run $20–$300/mo each — most stores carry 8–15 paid apps, so $200–$1,500/mo in subscriptions. A Shopify Plus store doing $10M GMV typically pays $50k–$120k/year in platform + apps + transaction fees.
Webflow
Site plans $14–$235/mo per site depending on traffic, plus workspace fees for multi-user teams. Can host marketing sites cleanly without WordPress’s plugin overhead. Limits on dynamic content, ecommerce features, and custom backend logic mean it’s typically not the right tool past Tier 2 marketing sites.
Headless platform stack
Frontend hosting on Vercel, Cloudflare Pages, or Netlify: $20–$500/mo depending on traffic. CMS like Sanity ($15–$199/mo per user, free tier exists), Storyblok ($90+/mo), Contentful ($300+/mo for team plans), or open-source Strapi (free self-hosted, $29+/mo Cloud). Total headless platform spend typically $200–$2,000/mo for a serious site.
Custom SaaS infrastructure
Database (Postgres on Neon, Supabase, or RDS): $20–$2,000/mo depending on size. Application hosting (Vercel, Railway, Render, Fly, AWS): $50–$5,000+/mo. Object storage, queue systems, observability (Datadog, Sentry, Better Stack), email infrastructure (Resend, Postmark, SES). Total infrastructure spend for a Series A SaaS typically $500–$5,000/mo and grows roughly linearly with customer count.
Geographic engineering rates in 2026
| Region | Junior | Senior | Agency blended | Trade-off |
|---|---|---|---|---|
| USA / Canada | $50–$80/hr | $120–$250/hr | $150–$300/hr | Time zone, communication, legal recourse — highest cost |
| Western Europe / UK | $50–$90/hr | $100–$180/hr | $130–$220/hr | Strong technical talent, EU/UK time zone |
| Eastern Europe | $30–$50/hr | $60–$100/hr | $70–$130/hr | Strong engineering culture, EU time zone |
| Latin America | $30–$55/hr | $70–$110/hr | $80–$140/hr | US time zone overlap, strong React/Node ecosystem |
| India / South Asia | $15–$30/hr | $30–$60/hr | $40–$90/hr | Massive talent pool, time zone challenge for US |
| Southeast Asia | $15–$30/hr | $30–$55/hr | $40–$80/hr | Similar economics, narrower senior pool |
The skill ceiling at the senior end is similar globally — a senior Next.js engineer in Warsaw is technically equivalent to one in San Francisco. Variance shows up in: junior-to-mid talent depth, project management discipline, communication overhead with non-overlapping time zones, and legal recourse if things go wrong (much harder offshore). The pattern that works: senior architect in your time zone, mid-level developers offshore for execution. Pure offshore on a complex build without senior oversight is where most cost-disaster stories come from.
Pricing models and which to pick
Time and materials (hourly billing)
Pay for hours worked. Maximum flexibility for scope changes, minimum cost predictability. Right when requirements are genuinely unclear and the design will evolve. The trap: agencies on T&M have weak incentive to ship fast. Use weekly checkpoints with budget caps to mitigate.
Fixed-price contracts
Agreed scope, agreed price, agreed timeline. Maximum budget predictability, minimum flexibility. Right for well-defined Tier 1 or Tier 2 builds where the scope can actually be specified upfront. Wrong for SaaS or Tier 3+ ecommerce where requirements will inevitably shift. Most fixed-price disasters happen when the scope was never as defined as both parties pretended it was — the agency cuts corners to hit the price; the client demands changes outside scope; the relationship deteriorates.
Retainer / subscription
Fixed monthly fee for ongoing design, development, and maintenance. The website becomes an evolving product rather than a static project. Guarantees prioritization and ongoing security patching; can become inefficient if you don’t consistently use the allocated hours. Increasingly the default model for serious post-launch work — most stores and applications need someone working on them every week, and the retainer formalizes that relationship.
Outcome-based / value pricing
Cost tied to measurable business outcomes (conversion rate lift, revenue impact, etc.) rather than hours. Aligns incentives well; difficult to structure honestly because attribution is hard and most outcomes have multiple causes. Where it works: well-instrumented funnels with stable baselines. Where it doesn’t: anything where the outcome depends as much on the client’s GTM execution as on the build quality.
FAQ
What’s a realistic budget for a B2B SaaS marketing site in 2026?
For a Series Seed to Series A SaaS, $25k–$60k is the typical range for a custom-designed marketing site that takes performance and SEO seriously, integrates with HubSpot or Salesforce, and ships in 8–12 weeks. Below $20k you’re getting templates with custom colors. Above $80k, the value is mostly in design polish and brand differentiation — worth it if your buyer’s first impression matters (it does), but not strictly necessary.
How much does it cost to build a SaaS MVP in 2026?
$15k–$60k for a real MVP scoped to one workflow, shipping in 2–4 months. SaaS starter kits (Supabase, Clerk, Stripe Billing, Tailwind UI) cut the cost substantially compared to building auth and billing from scratch. The MVPs that come in under $15k are usually scoped too narrowly to actually validate; the ones over $60k are usually scoped beyond what an MVP should be.
Why is custom ecommerce more expensive than custom SaaS at similar complexity?
Mostly the integrations. A SaaS product typically integrates with 3–5 third-party services (auth, billing, email, analytics, maybe a CRM). A serious ecommerce store integrates with 8–15: payment gateway, shipping carrier APIs, tax service, ERP, PIM, search, reviews, email, SMS, analytics, ad pixels, returns platform, fraud prevention, customer support. Each integration is engineering work and ongoing maintenance.
Is offshore engineering actually cheaper end-to-end?
Sometimes. The hourly rate is 3–5× lower; the productivity is rarely 5× lower for senior talent, but the project management overhead is often 2–3× higher (longer review cycles, time zone delays, communication friction). Net cost reduction is usually 30–60% on well-managed offshore engagements; on poorly managed ones, the rework wipes out the savings. The pattern that works: senior architect onshore, execution offshore.
What’s the minimum sustainable budget for a custom B2B website in 2026?
Roughly $20k for a custom-designed marketing site with proper performance, real CRM integration, and a content management system the marketing team can actually use. Below that, you’re either using templates (which is fine and honest) or you’re hiring someone who’s cutting corners somewhere you’ll discover later. The cost floor exists because the work below it is real — design hours, frontend implementation, SEO foundations, accessibility — and there’s no honest way to compress it into a few thousand dollars.
Want help scoping yours?
EtherLabz builds web design projects, ecommerce stores, and custom SaaS applications — and we’ll tell you honestly when a project should be Tier 1 instead of Tier 2, when an off-the-shelf platform beats custom, and when an integration’s actual cost exceeds the value it adds. Book a discovery call and we’ll scope your specific build with real numbers.
Written by Rupam, with input from the EtherLabz team.