Simplicity, Quality, and Continuous Improvement
At Seeking Sigma, we're not just building another app. We're on a mission to empower revenue teams. Our tech choices and principles reflect this mission - we've picked tools and practices that let us move fast, stay flexible, and maintain high quality. Let's dive in.
Our Tech Stack: The What
Next.js: Our Foundation
We started with Next.js, attracted by its server-side rendering, automatic code splitting, and built-in API routes. It was love at first sight. We built SimplePayments with it, and things were smooth sailing.
But as our project grew, we hit some serious roadblocks. The App Router migration left us scratching our heads - the documentation, while extensive, often felt like it was written in a different language. We spent more time deciphering how to implement features than actually building them.
Build times became our nemesis. What started as quick refreshes turned into coffee-break-worthy waits. This was killing our ability to iterate quickly, which is crucial for a startup like us.
We also felt increasingly boxed in. Next.js's opinionated nature, which initially seemed helpful, started to feel restrictive. We found ourselves fighting the framework more often than we'd like to admit, trying to bend it to our will for custom features.
Lastly, deployment became a pain point. While Vercel makes Next.js deployment a breeze, we wanted more control over our infrastructure. Deploying Next.js to our preferred setup was like solving a Rubik's cube blindfolded.
React + Vite and Node.js + Express: A Pivot
Frustrated, we turned to React with Vite, paired with Node.js and Express on the backend. The initial freedom was exhilarating. Vite's speed was intoxicating - our developers could make changes and see them instantly. We had full control over our server with Express, and keeping everything in JavaScript meant our small team could jump between frontend and backend tasks with ease.
But as we built out our application, reality set in. We found ourselves reinventing wheels that Next.js had provided out of the box. Simple things like routing and API handlers, which Next.js handled seamlessly, now required additional setup and maintenance.
Our "simpler" stack was getting complex, fast. We were spending more time on infrastructure and less on building features that mattered to our users. The initial speed boost from Vite was overshadowed by the time spent on tasks that Next.js had abstracted away.
We also missed Next.js's built-in optimizations. Things like automatic code splitting and image optimization, which we had taken for granted, were now our responsibility. Our bundle sizes grew, and our performance began to suffer.
The final straw was realizing how much we missed Next.js's static site generation and incremental static regeneration. These features had allowed us to build fast, dynamic sites without the complexity of managing a full server-side rendering setup.
The Return to Next.js
This experience made us appreciate Next.js in a whole new light. We realized that its "complexity" often saved us time in the long run. Its opinions weren't restrictions, but rather guardrails keeping us on the path of best practices.
So we swallowed our pride and went back to Next.js. But this time, we approached it differently. We embraced its constraints instead of fighting them, seeing them as helpful guidelines rather than restrictions. We learned to optimize our code to improve build times, and we went all-in on serverless deployment, simplifying our infrastructure headaches.
Now, our stack looks like this: Next.js, TypeScript, Tailwind CSS, Prisma, and Clerk for auth. It's not just a collection of trendy tools - it's a carefully considered set of technologies that help us bring our ideas to life.
MongoDB
Remember the days of writing complex SQL queries or wrestling with rigid relational schemas? Yeah, we don't miss that either. MongoDB has been a game-changer for us. It gives us flexible, document-based data storage that just works.
What we really love about MongoDB is how it bridges the gap between our data and our application code. It gives us greater flexibility, faster development, and happier developers.
We also investigated traditional relational databases, but figured that a document-oriented database would fit better for Seeking Sigma. MongoDB's schema-less design allows us to adapt quickly to changing requirements, while its powerful querying capabilities ensure we can still perform complex data operations when needed.
Tailwind CSS: Rapid UI Development
We'll be honest - we were skeptical about Tailwind at first. Utility classes? In our HTML? But after giving it a shot, we're converts. Tailwind lets us build UIs faster than ever before. We spend less time writing CSS and more time building features that our users actually care about.
As an added bonus, Tailwind's purging feature keeps our CSS bundle tiny, which means faster load times for our users. Win-win.
Authentication: Clerk Takes the Cake
When it comes to authentication, we don't mess around. Security is paramount, but we also didn't want to reinvent the wheel. Enter Clerk.
Why Clerk?
We'll be honest - initially, we were tempted to roll our own auth system. "How hard could it be?" we thought. Turns out, pretty hard if you want to do it right. Clerk came to our rescue, and we haven't looked back since.
Ease of Integration: Clerk slots into our React frontend and Express backend like they were made for each other. The SDK is intuitive, and the documentation is actually readable (a rarity in the auth world, trust us).
User Management Out of the Box: Clerk doesn't just handle logins; it gives us a full user management system. Password resets, email verification, user profiles - it's all there, saving us weeks of development time.
Multi-Factor Authentication: In today's security landscape, MFA isn't a nice-to-have; it's a must-have. Clerk makes implementing MFA a breeze, giving our users (and us) peace of mind.
Social Logins: Our users love being able to sign in with their Google or GitHub accounts. Clerk made setting this up so easy, we almost felt like we were cheating.
Our Principles and Practices: Quality at Speed
At Seeking Sigma, we believe that moving fast shouldn't mean breaking things. Here's how we maintain quality while keeping up the pace:
Code Quality: Our North Star
We're passionate about code quality. It's not just about satisfying our inner perfectionists (though that's a nice side effect). High-quality code means fewer bugs, easier maintenance, and faster feature development in the long run.
Code Reviews: Every line of code gets reviewed. It's not about nitpicking; it's about knowledge sharing and catching issues early.
Automated Testing: We write tests. Lots of tests. Unit tests, integration tests, end-to-end tests - you name it, we've got it. This gives us the confidence to ship changes quickly.
Linting and Formatting: We use ESLint and Prettier to keep our code consistent and catch potential issues early. It's amazing how much mental overhead this removes from the development process.
Version Control: Git as Our Time Machine
We use Git for version control, and we take it seriously. Our commit messages are clear and descriptive. We use feature branches and pull requests to manage our workflow. This approach not only helps us track changes but also facilitates our code review process.
Continuous Integration: Always Be Integrating
We've set up a robust CI pipeline using GitHub Actions. Every pull request triggers a series of automated checks:
Linting and type checking
Running our test suite
Building the application
This means we catch issues before they make it to our main branch. It's like having a tireless QA engineer working 24/7.
Deployment: Google Cloud Run and GitHub Actions
For deployment, we've embraced the serverless paradigm with Google Cloud Run. It's simple, scalable, and lets us focus on writing code rather than managing infrastructure.
Our deployment process is fully automated with GitHub Actions. When a pull request is merged to main:
Our CI checks run one final time
If everything passes, a new Docker image is built
The image is pushed to Google Container Registry
A new revision is deployed to Cloud Run
This setup means we can deploy multiple times a day with confidence. In fact, we often do!
Our Methodology: Keeping It Simple
You might have noticed a theme here - we like to keep things simple. This isn't just about our tech choices; it's a philosophy that permeates everything we do at Seeking Sigma.
We Ship Often: We're not fans of big, risky deployments. We prefer to ship small changes frequently. This keeps our feedback loop tight and helps us catch issues early.
We Embrace Constraints: We don't chase after every shiny new technology. Instead, we embrace the constraints of our chosen stack and push it to its limits.
We Value Readability: We believe that code is read more often than it's written. That's why we prioritize clear, readable code over clever one-liners.
We're Pragmatic: While we have our preferred ways of doing things, we're not dogmatic. If a different approach makes more sense for a particular problem, we're not afraid to deviate from our norms.
Build Fast & Break Things: Our Startup Mindset
Now, you might be thinking, "Wait a minute. You just talked about quality and now you're saying you break things?" Well, yes and no. Let us explain.
At Seeking Sigma, we've embraced the "Build Fast & Break Things" mindset, but with our own twist. We're not advocating for recklessness - far from it. Instead, this philosophy is about rapid iteration, learning from failures, and not being afraid to try new things.
Here's how we integrate this mindset with our tech stack and practices:
Rapid Prototyping: NextJS’ lightning-fast development server lets us quickly prototype new features. We can build, break, and rebuild in the time it would take other setups just to compile.
Feature Flags: We use feature flags extensively. This allows us to ship potentially breaking changes to production, but only enable them for internal testing. We can "break things" without affecting our users.
Monitoring and Logging: We've set up comprehensive monitoring and logging. When something does break, we know about it immediately and can quickly identify the cause.
Blue-Green Deployments: Our setup with Google Cloud Run makes it easy to implement blue-green deployments. We can quickly roll back if a new version introduces unexpected issues.
A/B Testing: We're not afraid to test bold new ideas directly with our users. Our stack makes it easy to implement A/B tests and quickly iterate based on real user feedback.
Embracing Failure: We view each "failure" as a learning opportunity. Our team culture encourages experimentation and doesn't punish honest mistakes.
This mindset, combined with our robust CI/CD pipeline and quality practices, allows us to innovate rapidly while maintaining a stable, reliable product for our users.
We're not just building fast - we're learning fast.
Wrapping Up
Our tech journey has taught us a crucial lesson: while the technology stack is important, it's ultimately just a tool to facilitate our vision. Our mission to empower revenue teams in the B2B SaaS space is what truly matters.
Our tech choices allow us to build faster, maintain quality, and iterate quickly, but they're not the star of the show. The star is our unique approach to revolutionizing revenue generation. What sets Seeking Sigma apart isn't our use of Next.js or our proficiency with modern web technologies. It's our deep understanding of the challenges faced by revenue teams and our innovative solutions to those problems.
We've realized that the ability to adapt our tech stack - to experiment, learn, and sometimes return to previous solutions - is valuable not because of the technologies themselves, but because it allows us to find the best way to implement our vision. This flexibility ensures that we're always in the best position to serve our users and bring our ideas to market.
At the end of the day, our users don't care whether we're using Next.js or Express, TypeScript or JavaScript. They care about how effectively we solve their problems and add value to their lives. Our tech stack is invisible to them; what they see is a solution that makes their lives easier and their businesses more successful.
So while we're proud of our tech decisions and the maturity we've shown in making them, we're even prouder of the ideas and innovations they support. At Seeking Sigma, we're not building a tech company- we're building the future of revenue teams. Technology is just the canvas on which we paint our vision.
As we move forward, we'll continue to make thoughtful tech choices, always with an eye on how they serve our greater purpose. But we'll never lose sight of what truly matters: the groundbreaking ideas that drive us, the problems we're solving, and the value we're creating for our users.
At Seeking Sigma, we're not just using these technologies and practices - we're leveraging them to revolutionize revenue generation for B2B SaaS. We're just getting started. Stay tuned - the best is yet to come.
