In the fast-paced world of software development, developers are often overwhelmed by endless framework choices and architectural trends. Over the years, I have refined a stack that balances simplicity, efficiency, and maintainability. A stack that has consistently delivered success across projects of all sizes.

Interestingly, I didn’t name it myself. A friend of a friend once called it the Simon Martinelli Stack after hearing my friend explain the technologies he was using, and it just stuck. I liked the idea because it reflects the consistency and philosophy behind my technology choices.

Why a Personal Stack?

Choosing technologies is not just about following the latest trends. It’s about finding tools that:

  • Are productive and enjoyable to use
  • Offer long-term stability
  • Scale with the complexity of the application
  • Encourage maintainable and efficient code

The Simon Martinelli Stack is built on these principles.

The Core Technologies

Here’s what I use, and why:

1. Java

  • Version: Always the LTS version (currently Java 21)
  • Why: Strong backward compatibility, performance, and an unmatched ecosystem.
  • Bonus: Java Records and Pattern Matching simplify code. New features are added every six months.

2. Spring Boot

  • Purpose: Application framework and dependency injection.
  • Why: Convention over configuration with a very rich ecosystem. Great Vaadin integration.
  • Minimalist Use: Only use what’s needed.

3. Vaadin

  • Purpose: Full-stack web framework for building UIs in Java.
  • Why: Strong type safety. One language for both frontend and backend. No separate SPA. No extra API layer unless necessary. No need for a separate frontend team.
  • Best Practice: Start simple! Customize later if needed.

4. jOOQ

  • Purpose: Type-safe SQL query construction.
  • Why: Write SQL but with type safety and Java fluency.
  • Alternative to JPA: More control, better performance, no surprises.

5. SQL Databases (PostgreSQL, Oracle)

  • Why: Solid RDBMS with mature features. The database lives longer than the application.
  • Tip: Design the database carefully and treat SQL as a first-class citizen.

Supporting Tools

  • Maven: Dependency management and builds.
  • Flyway: Database migrations. Keep schema changes under control.
  • Testcontainers: Integration testing with real database instances.
  • Docker: Packaging and deployment.
  • JUnit + AssertJ: Clean, expressive tests.
  • Spring Actuator + Micrometer: Observability and monitoring.

Architectural Principles

  • Self-contained Systems (SCS): Independently deployable units with their frontend, backend, and database.
  • Lean Development: Focus on eliminating waste. Fight overengineering.
  • Keep IT Simple: Simplicity is not a lack of sophistication, it’s a design goal.

Conclusion

In a world obsessed with complexity, the Simon Martinelli Stack offers:

  • Speed: Faster development cycles
  • Simplicity: Less cognitive load
  • Maintainability: Codebases that age gracefully
  • Performance: Efficient, predictable applications

It’s not a one-size-fits-all, but if you value pragmatism over hype, it might be exactly what you need.