BENCHMARK 01PostgreSQL FTS + Composite Haversine Index
Migrated from sequential full-table scans to compound indices, server-side Haversine trigonometry, and client worker pre-processing.
CURRENT SCAN: 95% latency reduction
João PauloDias Ventura
Node.js · Java · Go · Angular · AWS
Software Engineer specialized in financial systems, high-throughput data processing, concurrent architecture, and high-reliability distributed systems.
01/FINFinancial SystemsTransactional Outbox · Idempotency · ACID Settlement
02/DATAData PipelinesGo Worker Pools · Bounded Channels · Streams
03/DISTDistributed ArchitectureKafka · RabbitMQ · SQS · Event-Driven Microservices
04/PERFHigh Performance1.23 GB/s · 20ms Query Latency · Zero Memory Leaks
Impact & Benchmarks
Systems performance in production.
Measured volume, low-latency indexing, and streaming concurrency derived directly from production and benchmark results.
BENCHMARK 02Node.js Streams + Worker Threads
High-volume ingestion pipelines processing multi-gigabyte media without heap degradation using backpressure and worker concurrency.
BENCHMARK 03ACID Replica Sets · Transactional Outbox
Reduced manual reconciliation and operational overhead from days to minutes with end-to-end auditability and zero event loss.
Career Trajectory
Progression of systemic responsibility.
Trajectory at uFind Tecnologia: from interface optimization and search latency to high-volume media pipelines and critical financial automation.Jun 2025 - PresentFinancial Automation, ACID Transactions & Infrastructure
Mid-Level Software Engineer
uFind Tecnologia
End-to-end engineering of critical financial flows in production, spanning client architecture, microservices, databases, and infrastructure.
RESPONSIBILITY
End-to-end evolution of production financial systems, ACID transaction boundaries in MongoDB replica sets, and operational automation.
RESULTS & CONTRIBUTIONS
- Automated financial flows exceeding R$ 1 million monthly, reducing manual operations from days to minutes with zero data discrepancies.
- Implemented end-to-end system traceability with structured JSON logs, alerting, and real-time operational notifications.
- Reduced payload by ~10% across flows with over 1,300 records using client-side pre-processing and the Strategy Pattern.
- Modeled high-reliability MongoDB data schemas utilizing ACID transactions in Replica Sets to enforce strict financial consistency.
Node.jsJava / SpringMongoDB ACIDRedisStrategy PatternAWS
Featured Engineering Systems
Concurrency, consistency, and asynchronous architecture.
Production and engine case studies breaking down constraints, architectural decisions, failure modes, and benchmark results.01 / 04 Financial Core Banking Platform
Auronix
Digital bank ledger with accounts, concurrent transfers, and payment requests using Java/Spring Boot, PostgreSQL, and RabbitMQ.
Key DecisionsTransactional Outbox
atomic database-to-broker publication with zero event loss or duplicate ledger operations
Auronix // Transactional Settlement Pipeline
Demonstrates how financial transactions transition from client entry to atomic locking, outbox batching, worker execution, and real-time SSE propagation.
LOCK ACQUIRED -> BALANCE VALIDATED -> COMMIT -> EVENT DELIVERED
- Core Problem & Constraints
- Guaranteed balance consistency under high concurrency across simultaneous accounts and transfer operations.
- Engineering Scope
- End-to-end architecture & implementation of the financial ledger, outbox messaging, and settlement pipeline.
- Key Decisions
- Transactional Outbox with FOR UPDATE SKIP LOCKED batching, idempotent consumers by eventId, and deterministic pessimistic locks.
- Outcome & Metrics
- Transactional Outbox atomic database-to-broker publication with zero event loss or duplicate ledger operations
- Java
- Spring Boot
- PostgreSQL
- RabbitMQ
- Redis
- Angular
02 / 04 High-Throughput Compression Engine
GGCompress
Go engine for compressing large files concurrently with bounded memory consumption and verifiable binary archive formatting.
Key Decisions1.23 GB/s
peak throughput achieved across parallel worker pools on multi-core hardware
GGCompress // Parallel Stream & Assembly Flow
Splits large input streams into bounded chunks, distributes work across Goroutine worker pools, and enforces ordered writes with SHA-256 integrity.
LARGE FILE -> BOUNDED CHUNKS -> WORKERS -> ORDERED OUTPUT -> CHECKSUM
- Core Problem & Constraints
- Processes multi-gigabyte files in parallel while strictly bounding heap memory through backpressure and buffer pooling.
- Engineering Scope
- Designed and built the concurrent Go archiving engine, streaming chunker, and memory buffer manager.
- Key Decisions
- Combines sequential reads, worker pools, bounded channels, ring buffer reassembly, and per-chunk SHA-256 verification.
- Outcome & Metrics
- 1.23 GB/s peak throughput achieved across parallel worker pools on multi-core hardware
- Go
- Goroutines
- Worker Pools
- Bounded Channels
- SHA-256
- Binary Formats
03 / 04 Event-Driven Media Streaming Pipeline
X Tube
Distributed, event-driven video ingestion and transcoding pipeline utilizing Go, SQS, S3, FFmpeg, and Apache Kafka.
Key DecisionsS3 → SQS → Go → Kafka
fully decoupled ingestion, multi-bitrate transcoding, and progress notification flow
X Tube // Asynchronous Media Processing Pipeline
Traces video ingestion from S3 upload notifications to Go worker pool transcoding, S3 artifact persistence, and Kafka progress emission.
UPLOAD -> CLAIM JOB -> FFMPEG -> ARTIFACTS -> EVENT PUBLISHED
- Core Problem & Constraints
- Decouples media upload from intensive transcoding using SQS queues and worker visibility timeout heartbeats.
- Engineering Scope
- Led the asynchronous pipeline architecture, queue processing, and reliable worker lifecycle in a team of 3.
- Key Decisions
- Workers emit Kafka progress events upon every confirmed S3 chunk upload and delete queue messages only after full success.
- Outcome & Metrics
- S3 → SQS → Go → Kafka fully decoupled ingestion, multi-bitrate transcoding, and progress notification flow
- Go
- AWS SQS
- AWS S3
- FFmpeg
- Apache Kafka
- Prometheus
04 / 04 High-Concurrency Election Platform
Vox
Realtime election platform tested with 10,000 requests and 100 concurrent accesses on AWS EC2 t2.micro, used by 500+ voters at Etec.
Key Decisions106 req/s
100% success rate across 10,000 requests and 100 concurrent users on an AWS EC2 t2.micro instance
Vox // Concurrency Boundary & Realtime Serialization
Maintains atomic vote validation, ballot-box serialization, and real-time WebSocket broadcasts without race conditions.
CONCURRENT REQUESTS -> LOCK -> COMMIT -> NEXT
- Core Problem & Constraints
- Enforces atomic vote serialization per ballot box via PESSIMISTIC_WRITE locks inside a single transaction boundary.
- Engineering Scope
- Engineered the transactional voting serialization, database concurrency boundaries, and WebSocket telemetry.
- Key Decisions
- Delivers real-time vote count tallies via STOMP/WebSocket without blocking critical voting database transactions.
- Outcome & Metrics
- 106 req/s 100% success rate across 10,000 requests and 100 concurrent users on an AWS EC2 t2.micro instance
- Angular
- Spring Boot
- PostgreSQL
- PESSIMISTIC_WRITE
- STOMP / WebSocket
- AWS EC2
AI Agent
Ask the portfolio directly.
A deterministic question-answering console over the local portfolio knowledge base. It retrieves evidence, ranks it, reasons over the matched concepts, and abstains when the content is not supported.
Start with a concrete question.
Each request is isolated: only the question you send now is evaluated by the agent.
Stack & Engineering Pillars
Architecture framed around problem spaces.
End-to-end systems engineering: client interface architecture, distributed APIs, ACID storage, asynchronous message brokering, declarative infrastructure, and observability.
01 / Transactional & Financial Systems
- Java / Spring Boot
- PostgreSQL (Pessimistic Locks)
- Redis (Pub/Sub & Caching)
- Transactional Outbox Pattern
- ACID Replica Sets
02 / Concurrent Data Processing
- Go (Goroutines & Channels)
- Node.js Streams & Worker Threads
- Bounded Buffers & Backpressure
- SHA-256 Integrity Verification
- Vector Embeddings / Search
03 / Asynchronous & Event-Driven Systems
- RabbitMQ (Dead-letter & Idempotency)
- Apache Kafka (Partitioned Progress)
- AWS SQS & SNS
- SSE (Server-Sent Events)
- STOMP / WebSockets
04 / Cloud Infrastructure & Observability
- AWS (EKS, EC2, S3, Lambda)
- Docker & Kubernetes (Kubeconform)
- Terraform (Declarative IaC)
- Prometheus & Micrometer
- Structured JSON Telemetry
05 / System Interfaces & Clients
- TypeScript & Angular (Signals & SSR)
- Next.js & React
- Web Workers & Off-thread Processing
- Tauri Native Runtime
- WCAG AA / High Accessibility
Education & Certifications
Technical foundation in continuous progress.
Formal education in Artificial Intelligence and Systems Development, complemented by deep specialized certifications in Kubernetes, event-driven architectures, distributed data, and DDD.
Education
- FIAP | Aug 2026 - Jun 2028 | Artificial Intelligence
- Etec de Guarulhos | Feb 2023 - Dec 2025 | Systems Development
Certifications
- AWS: EKS and Event-Driven Architectures
- Alura: Software Architecture & Domain-Driven Design (DDD)
- FIAP: AI & Machine Learning Engineering
- MongoDB: Data Modeling & Financial Services
- EnterpriseDB: Distributed PostgreSQL Architecture
Languages
- Portuguese (Native / Fluent)
- English (Advanced / Professional)
Contact
Direct contact.
Public channels to discuss software engineering, financial systems, and reliable processing.
Email joaopdias.dev@gmail.com
LinkedIn linkedin.com/in/joaopdias-dev
GitHub github.com/Joaopdiasventura
LocationSão Paulo - SP