DEV Community: Luis Fernando Richter

Ask Richter: Building a Grounded AI Career Agent on Sanity's Structured Content Lake

Luis Fernando Richter — Sat, 03 Oct 2026 20:00:00 +0000

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

What I Built

Ask Richter turns a static software-engineering resume into an interactive, multilingual AI Career Agent.

Instead of treating my career history as a large block of text, I modeled it as structured, interconnected content covering:

Professional experiences
Projects
Skills
Education
Achievements
Architectural decisions

The application allows recruiters, engineering leaders, and developers to ask natural-language questions about my professional background in English, Portuguese, and Spanish.

The core design principle is:

Retrieve evidence first. Generate second.

The agent is designed to answer from retrieved evidence. When the required information is not present or cannot be verified, it abstains instead of inventing a fact.

For example, asking:

“Which projects use React?”

is handled differently from:

“What were the architectural challenges in building Ask Richter's RAG architecture?”

The first is a precise structured retrieval problem. The second is a semantic retrieval problem.

Relational questions can also use bounded knowledge-graph traversal across references between entities.

The result is a career agent where the underlying content model is part of the reasoning system, rather than simply a CMS sitting behind a chatbot.

Demo

Live application:
https://ask-richter-frontend.vercel.app/

The deployed application provides the conversational interface for exploring the structured career knowledge base.

Example queries:

Structured retrieval

Which projects use React?

The system identifies the technology relationship and retrieves the matching projects using deterministic structured retrieval.

Semantic retrieval

What were the architectural challenges in building Ask Richter's RAG architecture?

The system performs semantic retrieval over the architectural knowledge and generates an answer from the retrieved evidence.

Relational retrieval

Which technologies connect the Ask Richter project to Richter's professional experiences?

The system routes the query to the agentic retrieval path and attempts bounded traversal across the relationships modeled in Sanity.

Factual abstention

What was Richter's experience developing production systems in Rust?

When the required evidence is not available in the knowledge base, the system abstains rather than fabricating an experience.

Code

GitHub repository:
https://github.com/lfrichter/ask-richter

The repository contains the complete Turborepo monorepo, including:

Next.js application
Sanity Studio
Sanity schemas and migrations
Retrieval and orchestration code
Knowledge graph traversal
AI provider integration
Automated tests
Architecture Decision Records
Submission and regression evidence

How I Used Sanity

Sanity is the canonical knowledge layer for Ask Richter.

Rather than storing a traditional resume as one document, I modeled the career domain as interconnected typed entities in the Sanity Content Lake.

The current model contains six main schemas:

skill · experience · project · education · achievement · architectureDecision

The captured dataset contains 101 documents and 121 references at the time of the submission snapshot.

These references are important because the agent can reason about relationships between entities instead of relying exclusively on text similarity.

For example:

Project
   ├── uses → Skills
   ├── belongs to → Experience
   ├── documents → Architecture Decisions
   └── demonstrates → Achievements

Sanity MCP in the AI Engineering Workflow

The project also uses the official Sanity MCP server as part of the AI Engineering Agent (AGY) environment.

The MCP configuration points directly to the production Sanity project:

{
  "mcpServers": {
    "sanity": {
      "command": "npx",
      "args": [
        "-y",
        "@sanity/mcp-server@latest"
      ],
      "env": {
        "SANITY_PROJECT_ID": "q19ey6yx",
        "SANITY_DATASET": "production"
      }
    }
  }
}

This gives the engineering agent direct, schema-aware access to the same Sanity Content Lake used by the application.

During the final verification, the AGY used Sanity MCP tools including:

query_documents
list_workspace_schemas
get_schema
semantic_search

For example, a live MCP query:

count(*[_type == "project"])

returned 18 projects from the production dataset.

The MCP schema inspection also identified the deployed Ask Richter workspace.

This was particularly useful during development because the agent could inspect the actual content model and production data instead of relying on assumptions about the CMS.

The Sanity MCP server is designed specifically to let AI assistants interact with Sanity projects, including schema exploration, GROQ queries, and semantic search.

Structured Retrieval — M2

For deterministic questions, Ask Richter uses GROQ-based structured retrieval.

For example:

Which projects use React?

does not require vector similarity search.

The system can query the structured relationship between projects and technologies directly.

This provides deterministic retrieval for questions involving:

Technology filters
Project catalogs
Entity lists
Cardinality
Chronological information
Explicit relationships

Semantic Retrieval — M3

Open-ended questions require a different strategy.

Ask Richter uses Sanity Dataset Embeddings with text::semanticSimilarity() to retrieve semantically relevant content.

This is useful for questions where the user does not necessarily use the exact terminology present in the source material.

For example:

What were the architectural challenges in building Ask Richter's RAG architecture?

requires finding related architectural evidence rather than simply matching a specific project or technology field.

The retrieved evidence is then passed to the language model for grounded response generation.

Agentic Knowledge Graph Retrieval — M4

Some questions are relational rather than purely semantic.

For those cases, Ask Richter uses a bounded agentic retrieval layer built around the references in the structured content model.

The retrieval process has explicit execution limits:

Maximum 2 hops
Maximum 4 tool calls
4-second global timeout
Cycle detection
Read-only retrieval
No content mutation

The purpose of these limits is to prevent an open-ended agent loop while keeping relational questions useful.

The current implementation verifies first-order traversal scenarios such as project → skill relationships. More complex reverse multi-hop traversal remains intentionally bounded by the current execution budget.

Resilient Fallback

The application also maintains a pure TypeScript TSVectorStore as a deterministic fallback.

This replaced an earlier native FAISS dependency and helped move the application toward a fully serverless architecture.

The fallback uses in-memory vector calculations over the same 768-dimensional embedding space and is designed to preserve safe abstention when the primary retrieval path is unavailable.

Grounding and Abstention

Retrieval is separated from generation.

The application first determines the appropriate retrieval strategy, obtains evidence, and only then asks the language model to formulate the response.

If the retrieval layer cannot provide sufficient evidence, the agent does not attempt to fill the gap with general model knowledge.

This distinction is particularly important for a career agent.

A fabricated professional experience may sound plausible while still being completely false.

For Ask Richter, “I don't have enough evidence to answer that” is a valid system outcome.

Sanity Project Details

Sanity Project ID: q19ey6yx

Dataset: production

The Sanity Studio lives in:

apps/studio

The content model currently contains:

skill
experience
project
education
achievement
architectureDecision

The Sanity Content Lake is the canonical source for the career knowledge represented by the application.

The project uses structured references to preserve relationships between the entities rather than flattening everything into independent text documents.

The production snapshot used for this submission contains:

101 documents
121 references
18 projects

These values were verified against the production dataset during final validation.

Agent Session

The Ask Richter engineering workflow was developed and verified with an AI Engineering Agent (AGY) connected to Sanity through the official MCP server.

The session demonstrates how the agent can:

Inspect the Sanity schema
Query real production content
Inspect document relationships
Validate the structured content model
Verify retrieval behavior
Run regression checks against the resulting application

The MCP connection used the Sanity project:

q19ey6yx

and dataset:

production

A curated public Agent Session can be embedded here after publication through DEV's Agent Sessions interface.

Before publication, the transcript should be reviewed to ensure that no API keys, tokens, credentials, local paths containing sensitive information, or other private data are exposed.

Technical Architecture

At a high level, the system looks like this:

                     ┌──────────────────────┐
                     │       User           │
                     │    EN / PT / ES      │
                     └──────────┬───────────┘
                                │
                                ▼
                     ┌──────────────────────┐
                     │   Next.js 15 App     │
                     │    /api/chat         │
                     └──────────┬───────────┘
                                │
                                ▼
                     ┌──────────────────────┐
                     │ Intent Classifier    │
                     │      & Router        │
                     └───────┬──┬──┬───────┘
                             │  │  │
                 ┌───────────┘  │  └────────────┐
                 ▼              ▼               ▼
          ┌────────────┐ ┌────────────┐ ┌──────────────┐
          │ M2         │ │ M4         │ │ M3           │
          │ Structured │ │ Agentic    │ │ Semantic     │
          │ GROQ       │ │ KG         │ │ Embeddings   │
          └─────┬──────┘ └─────┬──────┘ └──────┬───────┘
                │              │               │
                └──────────────┼───────────────┘
                               ▼
                    ┌──────────────────────┐
                    │ Sanity Content Lake  │
                    │ Structured Knowledge │
                    └──────────┬───────────┘
                               │
                               ▼
                    ┌──────────────────────┐
                    │ Grounded Context     │
                    └──────────┬───────────┘
                               │
                               ▼
                    ┌──────────────────────┐
                    │ Gemini 3.6 Flash     │
                    └──────────┬───────────┘
                               │
                               ▼
                    ┌──────────────────────┐
                    │ Factual Answer or    │
                    │ Safe Abstention      │
                    └──────────────────────┘

There is also a separate engineering-time MCP path:

        AI Engineering Agent (AGY)
                    │
                    ▼
        Sanity MCP Server
        @sanity/mcp-server
                    │
                    ▼
        Sanity Content Lake
        q19ey6yx / production

This separation is intentional.

The MCP integration gives the engineering agent direct access to the real Sanity environment for schema inspection, querying, and validation.

The production application independently uses Sanity's APIs and retrieval capabilities to serve end-user questions.

Tech Stack

Knowledge Layer

Sanity Studio v3.78
Sanity Content Lake
GROQ
Sanity Dataset Embeddings
Structured document references
Official Sanity MCP server

Application

Next.js 15
React 19
TypeScript
Turborepo
Vercel Serverless

AI

Google GenAI API
gemini-3.6-flash
gemini-embedding-2
768-dimensional embeddings

Supporting Infrastructure

Supabase
Server-side resilience mechanisms
TypeScript in-memory vector fallback
GitHub Actions
AI Engineering Agent (AGY)

Engineering Quality

TDD-oriented development
Intent-routing regression tests
Jidoka validation pipeline
Automated integration tests
End-to-end HTTP regression scenarios
Architecture Decision Records

Verification

The final release candidate was validated through multiple independent gates.

Automated Tests

170 / 170 tests passing

151 frontend tests
19 backend tests

HTTP Regression

17 / 17 end-to-end HTTP scenarios passing

All verified scenarios returned successful HTTP responses.

Jidoka Validation

The full Jidoka pipeline completed successfully across the monorepo:

TypeScript type checking
Linting
Production builds
Test execution

Repository Integrity

git diff --check completed with zero errors.

The release candidate was committed and deployed to Vercel.

What I Learned

The most important lesson was that a structured content model changes what an AI agent can reliably do.

A conventional RAG pipeline often starts with:

“How do I retrieve the most similar text?”

This project led me toward a different question:

“What kind of information is the user actually asking for?”

Sometimes the answer is a structured query.

Sometimes it is semantic retrieval.

Sometimes it is a relationship traversal.

Trying to force all three problems through a single retrieval mechanism creates unnecessary ambiguity.

Sanity made it possible to represent the career domain as structured content first, and then build retrieval strategies around that model.

That changed the role of the CMS.

It became part of the reasoning architecture.

Final Thought

Ask Richter started as an experiment to make my resume conversational.

It evolved into a structured knowledge system where an AI agent has to remain accountable to the underlying evidence.

The goal was not to make an LLM sound confident about my career.

The goal was to make the agent answer from what the knowledge base can actually support.

Retrieve evidence first. Generate second. Abstain when the evidence is not there.

I Built Cat Guardian for My Seven Cats 🐾

Luis Fernando Richter — Mon, 17 Aug 2026 14:45:48 +0000

This is a submission for Weekend Challenge: Dog Days Edition

🐾 Cat Guardian — Protect. Identify. Find.

I live with seven cats: Kiara, Golia, Meias, Vaquinha, Tigrinha, Peluda, and Gamora. They all have different personalities, different appearances, and different routines.

And, like many pet owners, there is one thing that has always worried me: What if one of them gets lost?

That question became the starting point for Cat Guardian.

What I Built

Cat Guardian is a privacy-first digital safety passport for cats.

The idea is simple: give each cat a digital identity containing the information that could actually help if they ever go missing.

The platform provides:

🐈 Digital identity for each cat
🩺 Health records and vaccination tracking
🧠 AI-assisted visual identification
🏷️ Dynamic QR collar tags
🚨 Lost Mode
📱 Public rescue passport
🔐 Privacy-preserving contact between finder and owner
🌎 English and Brazilian Portuguese localization

The problem

When a pet goes missing, useful information is often scattered across photos, veterinary records, paper documents, and the owner's memory.

Traditional collar tags can also expose personal information such as phone numbers or addresses. I wanted a different approach.

The QR code attached to the collar doesn't expose the owner's contact information. Instead, when someone finds the cat, they can scan the QR code and access a public rescue profile.

If the owner has activated Lost Mode, the finder can submit a sighting. The owner is then notified through a secure backend relay.

Owner
  │
  ▼
Cat Guardian
  │
  ├── Digital Identity
  ├── Health Records
  ├── AI Profile
  └── QR Collar Tag
          │
          ▼
      Lost Mode
          │
          ▼
     Finder scans QR
          │
          ▼
    Public Rescue Card
          │
          ▼
     Submit Sighting
          │
          ▼
       Owner notified

The goal isn't to replace GPS trackers or microchips.

It is to make the information surrounding a lost pet available, structured, and safer to share.

Why AI?

I didn't want to add AI simply because this was an AI-related challenge.

I wanted to use it where it could provide practical value.

Gemini is used to analyze visual characteristics such as coat patterns, eye color, and distinctive markings and generate a structured identification profile.

The application also provides informational preventive wellness guidance, while explicitly keeping medical diagnosis and treatment outside its scope.

AI-generated profiles are also localized according to the user's language.

Demo

🌐 Open the Live Demo →

The application includes a Demo Mode, so you can explore the main experience without creating an account.

The demo contains my seven cats:

Kiara · Golia · Meias · Vaquinha · Tigrinha · Peluda · Gamora

Try the Lost & Found flow with the demo data and explore how a finder would interact with a cat's public rescue passport.

Key flows

1. Register a cat

Create a digital identity and add health information.

2. Generate a QR collar tag

The QR code points to the cat's public safety passport.

3. Activate Lost Mode

The owner can mark the cat as missing.

4. Finder scans the QR code

The finder sees the relevant rescue information without seeing the owner's private contact details.

5. Submit a sighting

The finder can send information about where and when the cat was seen.

6. Owner receives the notification

The backend relays the sighting to the owner through Resend.

Code

💻 GitHub Repository →

The project is open source and built with:

React 19
Vite 6
TypeScript
Supabase PostgreSQL
Supabase Auth
Row Level Security
Gemini
Ollama
Mistral 7B
OpenCoder 8B
Resend
i18next / react-i18next
Vitest
React Testing Library
ESLint

How I Built It

This project was also an experiment in AI-assisted software engineering.

I used my own AI Software Engineering Framework 2.0 to orchestrate the development process.

The goal was not simply to ask an LLM to generate the application.

Instead, I treated AI agents as specialized members of an engineering workflow.

Human Supervisor
       │
       ▼
Chief of Staff
       │
       ▼
   Risk Router
    /   |   \
   ▼    ▼    ▼
Mistral OpenCoder Gemini
   \    |    /
    \   |   /
      Jidoka
         │
         ▼
   Human Approval
         │
         ▼
       Merge

Risk-based agent routing

Simple and low-risk tasks were delegated to local models running through Ollama.

🟢 Mistral 7B

Used for tasks such as:

documentation
simple UI changes
repetitive work

🟡 OpenCoder 8B

Used for:

CRUD
forms
implementation tasks

🔴 Gemini

Used for higher-risk tasks such as:

authentication
Row Level Security
AI integrations
architectural decisions

This allowed me to keep the more capable model focused on tasks where it provided the most value.

Jidoka Quality Gate

Every implementation had to pass a validation pipeline:

Lint
  ↓
Typecheck
  ↓
Tests
  ↓
Build
  ↓
Human Approval

If a validation step failed, the workflow stopped instead of allowing the problem to propagate.

This follows the Jidoka / Andon Cord principle from my framework:

When an anomaly is detected, stop the process and fix it before continuing.

The final release candidate passed:

Gate	Result
ESLint	✅ PASS
TypeScript	✅ PASS
Vitest	✅ 21/21 PASS
Production Build	✅ PASS

Privacy-first architecture

The public rescue passport deliberately does not expose:

owner's email
phone number
physical address

The finder communicates through a backend relay.

Sightings are persisted in PostgreSQL and the owner is notified through the Resend API.

This creates a simple separation:

Finder
  │
  ▼
Public Rescue Passport
  │
  ▼
Sighting
  │
  ▼
Backend
  ├── PostgreSQL
  └── Resend
          │
          ▼
        Owner

The finder can help without gaining direct access to the owner's private contact information.

Internationalization

English is the default language, with Brazilian Portuguese as a secondary locale.

I also wanted AI-generated information to respect localization.

The localized AI profiles are stored in PostgreSQL using JSONB:

{
  "en": {
    "description": "...",
    "personality": "..."
  },
  "pt-BR": {
    "description": "...",
    "personality": "..."
  }
}

This keeps the cat's identity data together while allowing the presentation to adapt to the user's language.

Design System

The application uses a custom Midnight Guardian design system.

The visual language combines:

Midnight Navy
Lavender
Emerald
Amber
Coral

The goal was to make the application feel like a safety product rather than a generic pet CRUD application.

🔐 Privacy & Safety

Privacy was treated as a product requirement rather than an afterthought.

The public QR page is intentionally limited to information that can help identify and recover the cat.

Owner PII is not rendered publicly.

The system also does not attempt to provide veterinary diagnosis.

Cat Guardian provides informational preventive wellness guidance and does not replace professional veterinary advice.

🚧 Current Limitations

Cat Guardian is a hackathon prototype.

It does not currently provide:

real-time GPS tracking;
GPS collar hardware integration;
veterinary diagnosis;
guaranteed pet recovery.

These could be explored in future versions.

For this challenge, I intentionally focused on the digital identity, QR-based rescue flow, privacy-preserving communication, and AI-assisted identification.

🎯 What I Learned

The biggest challenge wasn't building the features.

It was deciding what not to build.

It would have been easy to add GPS, maps, mobile applications, IoT devices, blockchain, push notifications, and many other features.

But the core idea was much simpler:

Give a cat a digital identity that can help protect, identify, and reunite them with their owner.

Everything else had to support that idea.

And the project became much stronger because of that constraint.

🐾 Built for seven cats

Cat Guardian started with a very personal question:

What information would I want to have if one of my cats disappeared tomorrow?

I would want their photo.

Their identifying characteristics.

Their health information.

Their vaccination history.

Their microchip information.

And, most importantly:

I would want the person who found them to have a safe way to contact me.

That's Cat Guardian.

Built for:

Kiara · Golia · Meias · Vaquinha · Tigrinha · Peluda · Gamora

🐾

Prize Categories

I'm submitting Cat Guardian for:

🏆 Best Use of Google AI

Gemini is used meaningfully in the application for:

AI-assisted visual identification profiles
feline characteristic analysis
preventive wellness assistance
localized AI-generated content

Google AI is also used as the high-risk agent in the AI-assisted engineering workflow.

🔗 Links

🌐 Live Demo

💻 GitHub Repository

Built for the DEV Weekend Challenge: Dog Days Edition.

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