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.