Backend & Automation Engineer Software ArchitectureApplied AISecurity

I build systems that automate complex work.

I’m Bruno Moura, a developer focused on backend engineering, automation and applied AI. I build APIs, automations and integrations with reliability, security and scalability in mind from the first version.

View projects More about me

Fig. 1 Anatomy of a job

01 API Entry point

Receives the request, validates the contract and identifies the caller. Instead of holding the connection until the work is done, it answers 202 Accepted with an identifier to follow the job.

Input validation
Authentication and authorization
Idempotency keys

Python
FastAPI
REST

02 Orchestration Coordination

Turns the request into tasks, queues them and distributes them among workers. It controls concurrency, rate limits and retries, and follows the job from start to finish.

Queues and workers
Rate limiting
Retries with backoff

Redis
Queues
Workers

03 Automation Execution

Does the heavy lifting: navigates systems, collects data and integrates external services. Transient failures are expected, so each step can be safely repeated after a growing interval.

Web scraping
External integrations
Idempotent execution

Python
RPA
HTTP

04 AI Interpretation

Steps in when the data needs interpreting: classifying, extracting or summarizing. It runs in parallel with the automation as the data arrives, with local models when the data cannot leave the machine.

LLMs
Embeddings
Vector search

Ollama
FAISS
RAG

05 Processing Delivery

Normalizes, validates and stores the result, and notifies whoever needs to know. Every stage emits logs and metrics: that is what makes it possible to draw a trace like this one.

Normalization and validation
Persistence
Logs, metrics and traces

A conceptual model, not a running system. The API accepts the request and answers right away; the rest happens asynchronously, with retries when something fails.

Featured projects

Fig. 2 Illustration of the kind of analysis the project performs, with communities, the most central node and an isolated message. Not real data.

Prototype 2025

Signal Sense

Communication analysis with AI models that run locally.

Problem: Analyzing messages, emails and network logs with AI usually means sending sensitive data to external services.
How it works: A Python pipeline normalizes communications from CSV and JSON, maps who talks to whom in a graph, indexes the content as embeddings for semantic search and generates analyses with an LLM. The models run locally, through Ollama.

Python
FastAPI
Ollama
Qwen2.5 7B
nomic-embed-text
FAISS
NetworkX
scikit-learn
Streamlit
Docker Compose

Read case study Code on GitHub

data/output.json

"titulo": "ELE SÓ IA VISITAR O PAI NA FAZENDA, MAS ACABOU SENDO ABDUZIDO POR ALIENÍGENAS!",
1 Collection yt-dlp
"tema": "Ficção Científica ou Fantasia",
2 Classification Mistral via Ollama
"temas_semelhantes": ["Televisão (TV) ou Cinema","Aventura marinha ou Animais Marinhos"]
3 Similarity MiniLM + FAISS

Fig. 3 Output record published in the project’s README, in Portuguese as published, annotated with the pipeline step that produces each field.

Study 2025

Rabbit Hole Crawler

Classifies the video titles of a YouTube channel by topic.

Problem: Understanding what a channel covers means watching its videos or reading the titles one by one.
How it works: Collects the titles with yt-dlp (10 by default), classifies the topic of each one with a local LLM (Mistral via Ollama) and points out similar topics with embeddings and FAISS. The result is written to JSON.

Python
yt-dlp
Ollama
Mistral
sentence-transformers
FAISS

Read case study Code on GitHub

More experiments are on GitHub.

Engineering approach

Reliability: Unstable networks, timeouts and services that are down are part of the environment, not exceptions. So every step should fail in a predictable way and, whenever possible, recover on its own.

Explicit timeouts
Retries with backoff
Idempotency
Circuit breakers
Scalability: Growing should mean adding workers, not rewriting the system. That starts with splitting the work into independent tasks that can run in parallel.

Queues
Stateless workers
Horizontal scaling
Concurrency control
Security by Design: Security goes into the design, not at the end: validate input at the boundary, keep credentials out of the code and give each component only the access it needs.

Validation at the boundary
Secrets kept out of the code
Least privilege
Authentication and authorization
Observability: Without visibility, there is no way to operate a system. Structured logs, metrics and traces help to understand what it is doing and where it failed.

Structured logs
Metrics
Tracing
Actionable alerts
Automation: Repetitive work is a candidate for code. An automation only pays off when it checks every step, so the result can be trusted without constant supervision.

RPA
Task orchestration
Web scraping
Integrations between systems

Expertise

Backend Engineering & RPA

Main specialty

APIs that expose business processes, automations that replace repetitive manual work and integrations with systems that do not always offer an API.

Applied

Python
FastAPI
REST APIs
Process automation (RPA)
Web scraping
Integration with external systems
Task orchestration
Data processing

Public evidence

Software Architecture

Strong interest, in continuous study

Systems that keep responding under load and recover from failures: asynchronous work, queues, rate limits and isolation between components.

Applied

Docker and Docker Compose

Going deeper

Concurrency and asynchronous programming
Redis
Queues and workers
Rate limiting
Circuit breakers
Horizontal scaling
Observability
Fault tolerance

Public evidence

Services orchestrated with Docker Compose in Signal Sense

Applied AI

A relevant part of my technical background, applied in personal projects

Applications that interpret text: classification, semantic search and analysis with LLMs, including local models when the data cannot leave the machine.

Applied

Local LLMs with Ollama
Embeddings
Vector search with FAISS
AI integration in APIs

Going deeper

RAG
Vector databases
Fine-tuning
LoRA

Public evidence

Application Security

A relevant part of my technical background

APIs and automations that protect credentials and data, validate what they receive and expose only what is needed.

Applied

Secrets kept out of the code
Local AI models for sensitive data

Going deeper

API security
Authentication and authorization
Vulnerability identification
Offensive and defensive security fundamentals
Risk mitigation

Public evidence

About

Based in: São Paulo, Brazil
Education: Computer Science, in progress
Focus: Backend & Automation Engineering
Going deeper: Architecture, distributed systems, concurrency and scalability
Code: github.com/bruno-moura24

I develop software in São Paulo and study Computer Science. Professionally, I work on process automation and integration between systems, much of it in internal corporate projects that, for confidentiality, stay off this page.

The projects here are personal and public, and they work as a lab: locally run AI, semantic search and data processing. Alongside them, I’m going deeper into architecture, distributed systems, concurrency and scalability.

What interests me most is the part that is hard to show in a demo: what happens when the network fails, when the volume doubles or when someone uses the system in a way nobody expected.

Contact

For opportunities, projects or a technical conversation about automation, APIs and applied AI.

analisedigital@pm.me