Why We Built the Two Cents Software Stack

Every developer knows the feeling. You've got a brilliant SaaS idea, you're excited to build it, and then you hit the reality: before you can build anything unique, you need authentication, payment processing, team management, email systems, and security features.

Months of your time disappear into features that have nothing to do with your actual product.

Stefan and I had been through this cycle multiple times. Each time we started a new project, we found ourselves rebuilding the same foundational infrastructure instead of focusing on what made our product different. That repeated process led us to create the Two Cents Software Stack—not just another boilerplate, but a production-ready foundation specifically designed for the way modern developers actually work, with AI coding assistants, rapid iteration cycles, and a focus on shipping quickly without sacrificing quality.

The Problem We Kept Hitting

Every time we started a new SaaS project, the story was the same. Significant development time spent building the same foundational features: user authentication with email verification and password reset flows, payment processing with subscription management and webhooks, team management with role-based permissions, email systems with transactional and marketing capabilities, and security features like audit logs and session management.

The frustrating reality? The majority of development time went to features that provided zero competitive advantage. While we debugged OAuth flows and handled Stripe webhook edge cases, competitors were talking to customers and iterating on features that actually mattered.

We weren't alone in this struggle. Industry data shows that basic SaaS development costs can range significantly for a professional MVP, with typical timelines stretching several months when built from scratch. For non-technical founders without development backgrounds, these challenges are even more pronounced—and the complete guide to SaaS boilerplates for non-technical founders shows just how complex these decisions can become.

But there was another problem we noticed: the rise of AI coding tools was changing everything about how developers work, yet most boilerplates weren't designed for this new reality.

Building for the AI-Driven Era

When tools like Claude, ChatGPT, and GitHub Copilot entered the scene, everything changed about software development. Suddenly, developers could build features significantly faster than before. The bottleneck wasn't coding speed anymore—it was having clean, well-structured foundations that AI tools could understand and extend.

We realized that AI-assisted development needs something fundamentally different from traditional boilerplates. AI tools work best with clear patterns and conventions that they can recognize instantly. They need production-ready code with proper separation of concerns, not tutorials or demo code. They require comprehensive documentation that explains not just what the code does, but why architectural decisions were made.

This insight shaped our entire approach to building the Two Cents Software Stack. We didn't just create another boilerplate—we built a foundation specifically optimized for AI-assisted development.

Our stack includes clear patterns and conventions that AI tools understand instantly, making every interaction more productive. It's not a tutorial or demo code, but real features that handle authentication, payments, teams, and everything your SaaS needs. You skip weeks of foundational work and start building your unique features from day one.

Who We Built This For

When we started building the Two Cents Software Stack, we knew exactly who we were building for—because we were them or we worked for them.

Indie developers and solo founders who have the technical chops but limited time. They need to validate their SaaS idea quickly without spending months on infrastructure. They're building side projects that could become full businesses, and every hour spent on authentication systems is an hour not spent on customer acquisition.

Non-technical founders with a clear vision but no development background. They need a solid technical foundation they can hand to developers or agencies, knowing it won't need to be rebuilt as they scale. Understanding what's included in SaaS boilerplates versus what needs custom development helps these founders make smarter build-versus-buy decisions.

Vibe coders – developers who use AI coding assistants like Cursor and Copilot to move fast. They can write code with AI help, but they need professional infrastructure to build on. They're comfortable with modern tech stacks and want something that amplifies their productivity rather than getting in their way.

Development agencies building SaaS products for clients. They need a reliable foundation that lets them focus on client-specific features rather than rebuilding auth systems for the hundredth time. They're looking for something that reduces project timelines from 6+ months to 6-10 weeks while maintaining professional quality.

The common thread? Everyone we built for values speed to market, but refuses to compromise on quality to get there.

The Technology Stack Philosophy

Choosing our technology stack wasn't about following trends. It was about selecting tools that balance modern capabilities with proven stability, creating a foundation that's both powerful today and maintainable for years.

We chose .NET 10 because it provides enterprise-grade performance and stability while being completely free and open source. The framework handles everything from authentication to real-time features natively, reducing the dependency bloat that plagues many modern stacks.

React 19 gives us the latest component patterns and performance optimizations that developers expect, while maintaining backward compatibility with the vast React ecosystem. Combined with TypeScript, we get type safety that prevents entire categories of bugs before they reach production.

PostgreSQL serves as our database because it's the most feature-rich open source database available. It handles everything from simple CRUD operations to complex multi-tenant data isolation without requiring expensive enterprise licenses or complicated sharding strategies.

The entire stack is optimized for AI coding assistants. Clear separation of concerns means AI tools can understand your codebase and suggest relevant changes. Consistent patterns across frontend and backend make it easy to extend features without introducing bugs. Comprehensive documentation provides context that AI needs to generate production-quality code.

This isn't just theory. Developers using our stack with AI assistants report building features substantially faster than with traditional boilerplates, because the AI suggestions are consistently relevant and high-quality.

What Makes Our Approach Different

We've seen hundreds of SaaS boilerplates come and go. Most fall into one of two categories: oversimplified tutorials that require substantial work to become production-ready, or overengineered enterprise solutions with features you'll never use.

Neither serves the developers and founders we built this for.

Our approach is different because we think about boilerplates as invisible infrastructure, not user-facing features. The Stack provides Workspaces and Groups as building blocks for multi-tenancy and access control, but you're never forced to expose generic /groups routes. Instead, you build domain-specific features—Projects, Teams, Courses—that reference this infrastructure internally.

This separation matters tremendously when you're using AI coding assistants. The AI can understand that WorkspaceId provides multi-tenancy scoping without forcing you to design your entire application around generic "workspace" concepts. You build the product your users need while the infrastructure handles the plumbing.

We also designed with customization reality in mind. Understanding how much you can customize a boilerplate before it makes more sense to start over is critical—and our architecture makes it clear which parts are foundational infrastructure and which parts you're expected to modify.

The demo Task Manager we include isn't meant to be your production feature. It's a reference implementation showing you how to build domain features on top of infrastructure. Study it, learn from it, then remove it and build your own features.

Real Architecture for Real Businesses

One thing that frustrated us about other boilerplates was how they handled multi-tenancy. Many expose generic organization or workspace routes that force you to design your entire product around their specific abstractions.

We took a different approach inspired by how Clerk and WorkOS handle infrastructure: make it invisible.

Our Workspace entity provides multi-tenancy containers where each workspace has members and settings, and all data is scoped to workspaces. But you never expose generic workspace routes to users beyond administrative settings.

Groups provide flexible access control that can be used as Projects (like our demo shows), as Teams within organizations, as Departments for enterprise products, or as pure access control mechanisms for feature-level permissions. The infrastructure provides the mechanism; you decide the metaphor.

Your domain entities simply reference WorkspaceId and optionally GroupId. A Task references which Workspace it belongs to and which Group (Project, in the demo) it's associated with. A Course references its Workspace and maybe a Group for student cohorts. Your entities contain your business logic while leveraging infrastructure for scoping and access control.

This architecture keeps your domain logic clean and testable. When you write tests for your features, you can mock the infrastructure dependencies. When you need to change how access control works for your specific domain, you're not fighting against deeply coupled abstractions.

The Features That Actually Matter

When we decided what to include in the Stack, every feature had to meet three criteria: it's required for virtually every SaaS application, it's complex enough that building it correctly takes significant time, and it provides zero competitive advantage when built custom.

Our authentication system includes email/password authentication with proper security, OAuth integration with GitHub and other providers ready to add, email verification with customizable templates, password reset flows with security best practices, two-factor authentication for enhanced security, magic link authentication for passwordless login, session management with appropriate expiry policies, and comprehensive security audit logging.

Building all of this from scratch typically takes weeks of senior developer time. We spent months getting it right so you don't have to.

Payment processing and billing handles Stripe integration with subscriptions, invoicing, and webhooks, seat-based billing ready to implement for your pricing model, subscription lifecycle management including trials and upgrades, failed payment recovery with dunning management, tax calculation for global compliance, and webhook processing with proper error handling and retries.

Getting payment processing wrong creates immediate revenue problems and support headaches. We've handled the complexity so you can focus on pricing strategy rather than webhook debugging.

Multi-tenancy and team management provides workspace isolation ensuring complete data separation, team member management with invitation flows, role-based permissions with flexible access control, and group management for whatever abstraction your domain needs.

Building secure multi-tenancy takes weeks and getting it wrong creates devastating security vulnerabilities. We've implemented it properly, with clear patterns for how your domain features should leverage it.

Email infrastructure includes transactional email templates for auth and billing events, support for multiple providers (Resend, SendGrid, Mailgun), template management with easy customization, and proper error handling and retry logic.

Setting up reliable email that actually reaches inboxes is surprisingly complex. Our implementation handles the gotchas so your critical emails get delivered.

The Three-Tier Service Model

Building the Stack was just the foundation. We realized that most developers and founders needed more than just a boilerplate—they needed a partner throughout their entire SaaS journey. That's why we created Two Cents Software, our development studio built around the Stack.

Our service model reflects this reality. We start with the Two Cents Software Stack—our SaaS boilerplate that provides robust foundations with essential features already built and tested, ready for your custom requirements. This is the foundation that saves you weeks of development time and substantial development costs.

Then comes MVP development, where we build your unique features on top of the Stack foundation. This is where your competitive advantage comes to life. Instead of spending months on authentication and payments, you focus entirely on the features that make your product valuable to customers.

Finally, we provide ongoing support and maintenance. We don't disappear after launch. As your business grows, we help transform your MVP into a mature, scalable SaaS solution. We handle infrastructure updates, security patches, and architectural evolution as you scale.

We deliver MVPs in significantly shorter timelines using this approach, compared to traditional multi-month development cycles. This method reduces costs substantially while letting you focus on features that drive customer value and revenue.

Learning From Every Launch

Over the past two years, we've seen dozens of successful launches built on the Stack. Each one taught us something about what works and what doesn't in modern SaaS development.

We learned that founders significantly underestimate the complexity of "simple" features. What seems like a straightforward user management system actually involves invitation flows, role management, team switching, and data isolation—easily weeks of work even for experienced developers.

We discovered that most SaaS products need a substantial portion of common infrastructure and the remaining portion as unique features. The Stack handles that common infrastructure so you can invest all your resources into the features that actually differentiate your product.

We found that AI-assisted development substantially accelerates custom feature development, but only when working with clean, well-documented infrastructure. Messy codebases confuse AI tools and slow development to a crawl.

These insights continuously shape how we evolve the Stack. Every feature we add, every pattern we establish, every piece of documentation we write is informed by real-world usage across dozens of SaaS products.

What Success Looks Like

When we built the Two Cents Software Stack and our studio around it, success wasn't measured in lines of code or number of features. It was measured in how quickly developers could ship products that customers love.

Success is a solo founder launching their SaaS in weeks instead of months, with time left over to actually talk to customers. It's a non-technical founder confidently hiring developers, knowing they're building on solid infrastructure that won't need to be rebuilt. It's a development agency substantially reducing project timelines while maintaining the same quality standards their clients expect.

Success is developers using AI coding assistants to build features in hours that previously took days, because the Stack provides the clear patterns and context that AI needs to generate production-quality code.

Most importantly, success is founders spending their time on problems that matter—customer acquisition, product iteration, market fit—instead of debugging OAuth flows or wrestling with Stripe webhooks.

Getting Started With the Stack

The included documentation guides you through every aspect of the Stack. You'll understand how authentication works, how to implement custom features, how multi-tenancy isolation protects data, and how to deploy to production environments.

The demo Task Manager shows you a complete feature implementation from database to UI. It demonstrates how to structure your domain features, leverage infrastructure for access control, implement real-time updates with optimistic UI, and maintain clean separation between infrastructure and business logic.

When you're ready, you simply remove the demo code and build your own features following the same patterns.

The Honest Reality

Building the Two Cents Software Stack wasn't easy. We spent a lot of time getting authentication right, weeks perfecting the multi-tenancy architecture, and countless hours optimizing for AI-assisted development.

But that difficulty is precisely why we built it. Nobody should have to solve these problems from scratch for every SaaS they build. The authentication system that took us months to perfect should save you weeks. The multi-tenancy patterns we refined through trial and error should prevent you from making the same mistakes.

We built the TCS Stack because we were tired of rebuilding the same infrastructure for every project. We built it because we saw AI coding assistants changing everything about development velocity, but only for codebases that were properly structured. We built it because we wanted a foundation that respected our time and our users' data equally.

Most of all, we built it because the SaaS market is experiencing tremendous growth, and every day spent building commodity features is a day not spent building products that matter.

The TCS Stack is intentionally focused. It doesn't include every feature every SaaS might need—and that's by design. Evaluating SaaS boilerplates requires understanding what truly matters for your specific situation rather than chasing feature counts.

What the TCS Stack does provide is a solid, battle-tested foundation that handles the infrastructure complexity so you can focus on building something your customers actually want.