DEV Community: Luis Fernando Richter

Building a Robust API with Laravel, Clean Architecture, and SOLID Principles

Luis Fernando Richter — Fri, 17 Oct 2025 15:42:01 +0000

Excited to share a recent back-end project I architected and developed: the Favorite Products API. This isn't just another CRUD API; it's a practical case study on implementing Clean Architecture and SOLID principles with Laravel to build a secure, high-performance, and scalable solution.

The project is a RESTful API designed to manage user's favorite product lists, integrating with an external e-commerce service.

✨ Key Highlights & Challenges Overcome

Performance Optimization (N+1 Problem): I refactored the service layer to transform N+1 external API calls into a single, efficient bulk request (findProductsByIds), dramatically reducing latency.
Security First (IDOR Vulnerability): We patched a critical Insecure Direct Object Reference vulnerability by implementing strict, ownership-based authorization rules in the Form Requests. This is reinforced with feature tests covering 200, 401, and 403 status codes.
Decoupled & Testable Architecture: By using Dependency Inversion (Contracts/Interfaces), we fully decoupled our business logic from the external API client. This makes unit testing a breeze (just mock the interface!) and swapping data sources trivial.
Resilient Error Handling: Instead of letting external service failures fail silently (returning an empty 200 OK), the system now throws custom exceptions, which are caught by a global handler to return a meaningful 503 Service Unavailable response.

The entire stack runs on PHP 8.3/Laravel 12, PostgreSQL, and is containerized with Docker. We also have a comprehensive test suite using Pest and auto-generated, interactive documentation with OpenAPI (Swagger).

🔗 Open Source

The project is fully open-source. Feel free to explore the code, learn from the architectural decisions, or even contribute!

Check out the full source code on GitHub: lfrichter/favorite-products-api

I hope this can be a useful resource for anyone looking to deepen their understanding of modern back-end architecture.

Lightning-Speed Development with Bun and Hono ⚡

Luis Fernando Richter — Tue, 05 Aug 2025 13:00:00 +0000

Instead of just reading about the performance of Bun and the simplicity of Hono, I decided to put them to the test by building a Task Manager API. The result exceeded all my expectations and unveiled a new way of thinking about backend development.

![[lightning-speed-development-with-bun-and-hono.jpeg]]

Here are the highlights of this experience:

🏎️ Bun: The All-in-One Ecosystem That Eliminates Friction

Bun isn't just a runtime; it's a revolution in developer experience (DX).

Raw Performance: The server startup is instantaneous. In simple local benchmarks, my laptop hit peaks of 110,000+ requests/second. The memory usage was also incredibly optimized compared to Node.js.
Integrated Tooling: The best part is what you don't have to do. Bun comes with:
* ✅ An absurdly fast package manager.
* ✅ A native test runner (bun:test), allowing me to achieve 100% test coverage without setting up Jest, Vitest, or Mocha.
* ✅ Out-of-the-box support for TypeScript and JSX.

✨ Hono: The Magic of Simplicity for APIs

If Bun is the engine, Hono is the ultralight and aerodynamic chassis.

Minimalism and Performance: The code is clean and direct, with no boilerplate. The final bundle is just a few KBs, making it perfect for Edge Computing and serverless environments.
Total Flexibility: I wrote the API once, and I can deploy it anywhere: Bun, Deno, Cloudflare Workers, Vercel... Adhering to Web Standards makes all the difference.
TypeScript-First: The TypeScript experience is flawless. Autocomplete for route params, body, and headers is automatic, ensuring type safety across the entire application.

// The simplicity of Hono in action:
// A route to fetch all tasks with strong typing.

app.get('/tasks', (c) =\{
// 'c' (context) is fully typed\!
const tasks = db.query('SELECT \* FROM tasks').all();
return c.json(tasks);
});

🎯 The Dynamic Duo: Why Bun + Hono?

Together, they form the stack every developer deserves: fast, simple, and powerful.

True Agile Development: I went from "zero" to a fully tested CRUD in minutes, not hours. Less time configuring, more time creating value.
Fewer Headaches: Compared to a traditional stack (like MERN), the number of development dependencies and configurations to manage is drastically lower.
Production-Ready: The structure is naturally scalable and easy to test, creating a solid foundation for serious projects from the get-go.

The complete project is on my GitHub, with the full folder structure, tests, and documentation for anyone who wants to explore it.

👉 [https://github.com/lfrichter/hono-task-manager]

Ready to see for yourself? Try this combination and let me know what you think in the comments! 👇

I Built an Tool to AI Agent Testing

Luis Fernando Richter — Fri, 25 Jul 2025 00:06:12 +0000

Excited to share my latest open-source project: the AI Agent Tester!

As AI models become more integrated into our applications, how do we ensure their responses are consistent and reliable? Manually testing prompts is slow and doesn't scale. That's why I created this tool.

The AI Agent Tester automates the validation process. It reads prompts from a simple CSV file, sends them to an AI (like OpenAI's GPT), and checks the responses for expected keywords.

Here’s what makes it effective:

Intelligent Validation: It uses "stemming" with NLTK to recognize word variations (e.g., 'fly', 'flying', 'flew'), making validation more robust.
Detailed Reports: It generates a JSON report with the status (Success/Fail) for each prompt, along with the AI's full response.
Easy to Use: Built with Python and requires minimal setup. It even has automatic proxy support for corporate environments.

This project is for any developer or QA engineer working with Large Language Models who wants to add a layer of automated testing to their workflow.

It's open-source, and I would love to get your feedback or contributions!

Check out the project on GitHub: https://github.com/lfrichter/ai-agent-test

The Essence of Development: Unravelling the Complexities to Build High-End Applications

Luis Fernando Richter — Thu, 17 Jul 2025 20:28:44 +0000

As developers, we dive daily into a sea of lines of code, features, and challenges. But before any technological choice, there is a fundamental truth that guides the success of any application, especially those built for established businesses: the clear distinction between business complexity and technical complexity.

The Two Faces of Complexity

Business complexity resides in the rules, processes, and nuances of the very domain in which we operate. It would exist even without a single line of code. Think of the intricate tax regulations of an e-commerce site or the credit approval process of a financial institution. This is the essence, the "why" of our work.

Technical complexity, on the other hand, is what we, as developers, introduce with tools, frameworks, architectures, and implementation decisions. While necessary to bring the solution to life, it should serve the business, not the other way around.

From Distinction to Powerful Architectures

When we cultivate the ability to clearly perceive and map this difference, something magical happens: we elevate our application to a new level. By focusing on accurately modelling the business, isolating it from purely technical concerns, we open the doors to Clean Architecture and Hexagonal Architecture. These approaches allow us to build systems that are more maintainable, testable, and adaptable to business changes, as the core of the application—the business logic—remains cohesive and independent of external layers.

Deepening the Solution with Domain-Driven Design

And if the challenge is to build a robust system for a complex, large-scale business, Domain-Driven Design (DDD) becomes a powerful ally. By immersing ourselves in the domain, in the language of business experts, and translating it into a rich, cohesive model, we build software that truly solves business problems in an aligned and evolving manner.

Conclusion: Build for the Business First

In short, the journey to building high-level applications begins with a careful look at the nature of the complexity we face. By honouring the distinction between business and technology, we pave the way for solid architectures and, consequently, for the success of the product and the business it serves. Remember: understanding the core business is the first step to building solutions that truly make a difference.

My end-to-end automated YouTube video factory

Luis Fernando Richter — Sat, 12 Jul 2025 20:35:16 +0000

I'm excited to share the MVP of my latest personal project: a fully end-to-end automated YouTube video factory. This system is designed to transform a simple text idea into a complete, published video, supporting both short-form (Shorts) and long-form content.

It orchestrates a suite of powerful APIs and tools to automate the entire workflow:

Scripting: OpenAI API (GPT)
Voiceover: ElevenLabs API for high-quality TTS
Visuals: Flexible image generation via Replicate (SDXL) or a cost-effective alternative using the Pixabay API
Subtitles: Precise, locally-run transcription with OpenAI Whisper
Music: Royalty-free background music sourced from the Jamendo API
Assembly: A robust, two-step FFmpeg process that ensures smooth, "judder-free" animations
Publishing: Direct upload to YouTube via the YouTube Data API v3

Beyond just connecting APIs, the focus was on building a resilient and developer-friendly system. This includes:

A comprehensive health_check.py script to validate the environment.
Automated pytest tests for key integrations like Pixabay and Jamendo to handle API errors gracefully.
A full scheduling system for macOS using launchd to automate future uploads.

This project was a deep dive into system architecture, complex automation pipelines, and solving low-level integration challenges.

You can see the system's architecture in these diagrams:

Application Flowchart: https://bit.ly/4kzoxby
Sequence Diagram: https://bit.ly/46EHd6h

I'm always open to feedback and connecting with fellow developers!

Never Leave Your Inbox 📥 A Task Manager Powered by Simple Email Replies

Luis Fernando Richter — Mon, 09 Jun 2025 02:45:00 +0000

Hello everyone! This is my submission for the Postmark Challenge: Inbox Innovators on DEV.to. I decided to tackle a common problem for many of us: tasks that originate from emails often force us to switch contexts, copy-pasting content into a separate to-do application.

My solution? An application that transforms your email client into a fully-fledged, conversational task manager.

The Core Idea: Email as an Interface

Instead of just being a place where tasks arrive, what if the inbox could be the interface where you manage their entire lifecycle?

My project allows a user to:

Create a task by sending a simple email.
Receive an instant confirmation that creates a conversational thread.
Update, comment on, and complete the task just by replying to that thread with simple commands.

This creates a seamless workflow, keeping the user right where they are, without ever needing to open another app.

How It Works: The Conversational Flow

The magic happens through a combination of Postmark's Inbound and Outbound APIs and a command parser built in Laravel. The entire flow is conversational.

Here is a sequence diagram illustrating the process:

Let's see it in action with a simple story: updating a page on a website.

1. The First Email (Task Creation)

I send an email to the system's inbound address. The body contains a description of the task and some commands to set the priority and due date right away.

Subject: 📄 Update 'About Us' page on the company website

Body:

The 'About Us' page is outdated. Please update the text to reflect our new company values and add the latest team photos. The photo assets are in the shared drive.

#priority medium

My application receives this, creates the task, sets the priority, and cleans the description.

2. The Reply (Adding a Comment)

After receiving the confirmation email, I can reply to it to add a comment or ask a question.

Subject: Re: [TASK-2] 📄 Update 'About Us' page on the company website

Body:

The content team is ready to start, but they have a question first. 🤔

#comment Should we also update the individual team member bios, or just the main company description for now?

The application receives this reply, finds the original task, and attaches the new comment.

3. The Final Reply (Task Completion)

Once the work is done, a final reply with the #complete command is all that's needed.

Subject: Re: [TASK-2] 📄 Update 'About Us' page on the company website

Body:

Just confirmed with the director. For now, only update the main company description.

#comment The content team has confirmed the changes are now live on the site. Everything looks great. ✔️
#complete

The task is now automatically marked as completed in the UI.

The Tech Stack

To bring this idea to life, I used the following technologies:

Backend: Laravel 12
Email Processing: Postmark API (Inbound and Outbound)
Frontend: Livewire with Blade
UI & Icons: Tailwind CSS & Blade Heroicons
Testing: Pest (PHP Testing Framework)

A Glimpse into the Implementation

One of the core components is a CommandParser service in Laravel. It uses a simple but powerful regex-based approach to find and process commands within the email body. This service is responsible for updating the task's attributes or creating related records, like comments.

Another key piece was using Laravel's event system. By listening to the MessageSent event, the application captures the unique Message-ID of the outgoing confirmation email. This ID could be used in the future to build an even more robust system for threading replies.

Live Demo in Action

To demonstrate the application's flow in real-time, I recorded a short video showing the complete lifecycle of a task, from creation to completion, all managed via email.

youtu.be/NDFgcH2X1ZI

Conclusion

This project was a fantastic exercise in thinking about email not just as a destination, but as an interactive platform. By leveraging Postmark's powerful APIs, it's possible to build truly innovative and seamless workflows that meet users where they already are: their inbox.

Thank you for the challenge!

Find the full source code on my GitHub repository: Interactive-email-management