Ricardo Huaripata

firstName

lastName

email

message

Let’s talk... 💬

Choosing a tech stack is one of the most important decisions when starting any web development project. Throughout my journey as a developer, I have experimented with various tools and languages, but I have finally found a stack that combines productivity, scalability, and ease of use: Spring Boot, MySQL, Angular, and TailwindCSS. In this post, I want to share the reasons behind my choice and why I believe this stack is an excellent option.

## Backend: Spring Boot

Spring Boot is the cornerstone of my backend. This Java-based technology offers a robust and flexible framework for building modern applications. Here are the main reasons why I chose it:

- Productivity: Spring Boot eliminates much of the tedious configuration associated with traditional Java projects thanks to its auto-configuration features. This allows me to focus on business logic without worrying about complex setup tasks.

- Scalability: Its modular architecture gives me confidence that my application can grow and handle a high volume of users without sacrificing performance.

- Community and Support: Spring Boot has a very active community and exceptional documentation. This means that if I encounter any issues, there is likely already a solution or resource available.

- Integration with Enterprise Tools: It is ideal for applications that need to connect to enterprise systems, handle complex transactions, or integrate REST services efficiently.

## Database: MySQL

For the data layer, I chose MySQL, one of the most popular relational databases in the world. The reasons for this choice include:

- Reliability: MySQL is known for being stable and reliable, even in high-demand production environments.

- Ease of Use: Its syntax is simple and familiar, enabling me to manage and query data efficiently.

- Compatibility with Spring Boot: Spring Data JPA makes it easy to integrate MySQL with Spring Boot. This allows me to interact with the database using an object-based API, saving time and effort.

- Documentation and Community: Like Spring Boot, MySQL has extensive documentation and an active community, ensuring that any questions can be resolved quickly.

## Frontend: Angular

On the frontend side, my choice was Angular, the development framework maintained by Google. Here’s why Angular is my go-to tool:

- Robust Structure: Angular provides a component-based approach and strong typing with TypeScript, which helps keep code organized and scalable.

- Support for Complex Applications: Angular is perfect for building rich, interactive user interfaces. Its modularity system enables me to manage large projects without losing control.

- Two-Way Data Binding: The automatic synchronization between model and view makes interactions smooth and reduces the amount of required code.

- Ecosystem and Tools: Angular CLI, its command-line interface tool, speeds up development with component generation, services, and built-in testing support.

## Styling: TailwindCSS

For styling, I chose TailwindCSS, a utility-first framework that allows me to design clean and modern interfaces quickly. Here are the reasons behind this choice:

- Utility-Based Design: Instead of writing CSS from scratch, Tailwind provides predefined classes that can be combined to achieve any design effortlessly.

- Development Speed: By using utility classes, I can test and adjust styles directly in the HTML code without switching between CSS files.

- Visual Consistency: Tailwind includes a predefined design system with typography, colors, and spacing, ensuring the interface remains consistent.

- Flexibility: While it comes with default values, everything can be customized to fit the project’s needs.

## Final thoughts

Choosing a tech stack is no trivial decision. It requires considering the project’s needs, community support, learning curve, and market trends. For me, this stack has been a solid choice, and I hope this post has inspired or provided you with ideas for making your own tech decisions. Thanks for reading!


How I chose my tech stack and why

How I chose my tech stack and why 🛠️

Every developer’s journey is unique, shaped by the challenges faced, the tools learned, and the projects built. Mine began in a structured environment: an Advanced Technical Degree in Web Application Development. Over two years, I transitioned from a complete beginner to a full-stack developer, learning the foundational principles and advanced technologies that now form the backbone of my career. Here is my story.

## Year 1: Building the Foundations

The first year of my program was all about mastering the basics. This was the stage where I learned what development really entails and began building the foundation for my future skills.

#### Programming in Java

I started with Java, which introduced me to core programming concepts like object-oriented programming, data structures, and algorithms. Java’s versatility and widespread use made it a great starting point, and it also prepared me for backend development down the line.

#### Databases and SQL

Understanding how data is stored, managed, and queried was another key milestone. I dove into SQL and database design, learning how to create schemas, write complex queries, and optimize data storage—skills that are essential for any developer.

#### HTML and CSS

Web development began with HTML and CSS, the building blocks of any website. I explored how to structure content and style it effectively, laying the groundwork for more complex frontend frameworks I’d encounter later.

#### Software Lifecycle

I also studied the software development lifecycle, gaining insight into how professional software projects are planned, executed, and maintained. This knowledge was invaluable for understanding the big picture of how applications come to life.

#### Systems and Docker

One of the most exciting parts of the first year was learning about systems administration and tools like Docker. Containerization introduced me to modern development workflows, enabling me to set up isolated environments and simplify deployments. This was my first taste of how powerful DevOps practices could be.

## Year 2: Becoming a Full-Stack Developer

The second year was where everything came together. This was the time to specialize, deepen my knowledge, and combine the backend and frontend skills to build complete applications.

#### Backend Development with Spring Boot

Building on my Java foundation, I learned Spring Boot, a powerful framework for creating robust and scalable backend applications. I became proficient in building RESTful APIs, handling authentication, managing databases, and implementing business logic.

#### Frontend Development with Angular

On the frontend side, I learned Angular, which transformed how I approached user interfaces. Angular’s component-based architecture, combined with TypeScript, enabled me to create dynamic, responsive, and maintainable web applications.

#### Web Application Deployment

One of the most critical skills I gained was web application deployment. I learned how to host applications on servers, manage domains, and ensure that projects were accessible to users. This included working with build tools and automation processes to streamline deployments.

#### Cloud Computing

Finally, I explored cloud computing, which opened the door to scalable, flexible infrastructure. Learning how to deploy and manage applications in the cloud helped me understand modern hosting solutions like AWS, Azure, and Google Cloud, preparing me for real-world scenarios.

## Specializing Through Personal Projects

After completing my formal education, I knew the journey didn’t stop there. To further strengthen my skills and gain hands-on experience, I started working on personal projects. These projects allowed me to:

- Deepen my backend expertise: I built APIs with Spring Boot, experimenting with advanced features like custom security implementations, complex query optimizations, and performance tuning.

- Enhance my frontend skills: Using Angular, I created dynamic, responsive web applications, honing my ability to design intuitive user interfaces and manage state effectively.

- Improve my deployment process: I practiced deploying projects using Docker and cloud platforms, focusing on automating workflows and improving scalability.

These personal projects not only solidified my technical knowledge but also helped me understand how to solve real-world problems creatively and efficiently.

## Final Thoughts

Becoming a full-stack developer is not just about learning technologies; it’s about understanding how to connect them to create seamless experiences. My formal education provided a structured path, but it was the curiosity and dedication to go beyond the classroom that truly defined my journey.

If you’re starting out, remember: every expert was once a beginner. Focus on building a strong foundation, embrace challenges, and keep pushing forward. The results are worth it!


My journey from beginner to full-stack developer

My journey from beginner to full-stack developer 👨‍💻

Blog