🚀 Software Engineer & Solutions Architect, specialized in Cloud-Native Architecture and Enterprise System Modernization
💼 Polyglot Engineer building high-performance systems with Go, Java, and Kotlin
🏗️ Solutions Architect designing scalable architectures for critical banking applications
🏦 Former Mainframe-to-AWS migration engineer for Itaú's Core Banking systems
☕ Expert in Java ecosystem (Spring Boot, Micronaut) and Kotlin for JVM applications
🦀 Passionate about Go, Rust, Database Internals, and System Design
📍 Based in Santa Catarina, Brasil

☕ Spring Boot REST API Template Java • Spring Boot • PostgreSQL • SOLID Production-ready REST API with MapStruct, OpenAPI docs, Docker, and Clean Architecture	🚀 Go GraphQL Boilerplate Go • GraphQL • gqlgen • SOLID Production-ready GraphQL API with PostgreSQL, JWT auth and Clean Architecture principles
🏦 Mainframe to Cloud Migration Go • AWS • Microservices • Architecture Enterprise documentation of IBM Z Mainframe modernization with Go microservices	🗄️ ApexStore Rust • Database Internals • LSM-Tree High-performance Key-Value Store using LSM-Tree architecture with WAL and SSTables

// Java & Kotlin alongside Go for enterprise systems
public class CurrentFocus {
    record Focus(String area, List<String> technologies) {}
    
    public static void main(String[] args) {
        var focus = List.of(
            new Focus(
                "🏦 Core Banking Modernization",
                List.of("Go", "Java", "Spring Boot", "AWS", "Kafka")
            ),
            new Focus(
                "🏗️ Solutions Architecture",
                List.of("Go", "Kotlin", "Terraform", "Kubernetes", "gRPC")
            ),
            new Focus(
                "🚀 High-Performance Systems",
                List.of("Go", "Java 21", "Rust", "Virtual Threads", "GraalVM")
            ),
            new Focus(
                "📚 System Design & Architecture",
                List.of("Microservices", "Event-Driven", "CQRS", "DDD")
            )
        );
        
        focus.forEach(f -> 
            System.out.printf("%s: %s%n", f.area(), f.technologies())
        );
    }
}

Cloud-Native Architecture | Mainframe Modernization | Polyglot Engineering

• Designing enterprise-grade architectures for critical banking systems
• Leading cloud migration strategies from Mainframe to AWS
• Architecting microservices ecosystems using Go, Java/Spring Boot, and Kotlin
• Implementing event-driven architectures with Kafka and reactive streams
• Working directly with Itaú on Core Banking modernization initiatives

• Building high-performance microservices in Go and Java/Spring Boot
• Developing RESTful and GraphQL APIs with multiple tech stacks
• Implementing distributed systems with Go for real-time processing
• Creating Spring Boot templates following Clean Architecture and SOLID principles
• Integrating legacy COBOL/Mainframe systems with modern services

• Primary: Go, Java 17+, Kotlin, Spring Boot 3.x
• Cloud: AWS (ECS, EKS, Lambda), Terraform, Kubernetes
• JVM: Spring Boot, Micronaut, Hibernate, MapStruct
• Databases: PostgreSQL, DynamoDB, Redis, MongoDB
• Messaging: Apache Kafka, AWS SQS, RabbitMQ
• Observability: Prometheus, Grafana, ELK, Jaeger

• ✅ Architected polyglot microservices (Go + Java/Kotlin) handling 5M+ daily transactions
• ✅ Reduced system latency from 850ms to 120ms using Go and Java optimizations
• ✅ Designed scalable architecture supporting 15,000 TPS with hybrid Go/JVM services
• ✅ Created production-ready Spring Boot templates with SOLID principles
• ✅ Led migration of critical banking systems to cloud-native microservices
• ✅ Implemented event-driven architecture with Kafka consumers in Go and Java
• ✅ Achieved 67% cost reduction through efficient service design

@Service
@Transactional
public class UserServiceImpl implements UserService {
    private final UserRepository repository;
    private final UserMapper mapper;
    
    @Override
    public UserResponse createUser(CreateUserRequest request) {
        if (repository.existsByEmail(request.email())) {
            throw new DuplicateResourceException("Email already exists");
        }
        
        var user = mapper.toEntity(request);
        user.setPassword(passwordEncoder.encode(request.password()));
        
        return mapper.toResponse(repository.save(user));
    }
}

• ⚡ Spring Boot 3.x: REST APIs, validation, exception handling, profiles
• 🏗️ Clean Architecture: Layered structure with SOLID principles
• 📦 MapStruct: Type-safe DTO mapping
• 🔐 Spring Security: JWT, OAuth2, BCrypt
• 🎯 Production-Ready: OpenAPI docs, Docker, comprehensive testing
• 🔧 Frameworks: Spring Boot, Micronaut, Quarkus, Hibernate
• 🌐 Kotlin Coroutines: Async/reactive programming

// Go's concurrency for high-throughput systems
func (s *TransactionService) ProcessBatch(ctx context.Context, txns []Transaction) error {
    var wg sync.WaitGroup
    errChan := make(chan error, len(txns))
    
    for _, txn := range txns {
        wg.Add(1)
        go func(t Transaction) {
            defer wg.Done()
            if err := s.process(ctx, t); err != nil {
                errChan <- err
            }
        }(txn)
    }
    
    wg.Wait()
    close(errChan)
    
    return <-errChan
}

• ⚡ High-Performance APIs: Low-latency REST and GraphQL services
• 🔄 Concurrency Patterns: Goroutines, channels, sync primitives
• 📦 Microservices: Distributed Go services with gRPC
• 🔧 Frameworks: Gin, Echo, Fiber, gqlgen, GORM, sqlx

Production-ready Java template featuring:

• ✅ Spring Boot 3.x + Java 17: Modern JVM stack
• ✅ Clean Architecture: Controller → Service → Repository
• ✅ DTOs with Records: Immutable request/response objects
• ✅ MapStruct: Compile-time safe mapping
• ✅ Global Exception Handling: @ControllerAdvice with custom exceptions
• ✅ Bean Validation: Jakarta validation on all inputs
• ✅ OpenAPI/Swagger: Auto-generated API documentation
• ✅ BCrypt: Password hashing with Spring Security config
• ✅ Docker + PostgreSQL: Complete containerized setup
• ✅ Unit Tests: JUnit 5 + Mockito examples

SOLID Principles Applied:

• Single Responsibility, Open/Closed, Liskov Substitution
• Interface Segregation, Dependency Inversion

Production-ready Go template featuring:

• ✅ GraphQL with gqlgen: Type-safe API development
• ✅ PostgreSQL + GORM: Database layer with migrations
• ✅ JWT Authentication: Secure auth middleware
• ✅ Docker + CI/CD: Complete deployment pipeline

Hybrid architecture showcasing:

• Legacy: IBM Z Mainframe (COBOL) → Modern: Go + Java microservices
• Performance: 5M daily transactions, 15,000 TPS
• Stack: Go (high-throughput), Java/Spring Boot (business logic), Kotlin (async services)

• 🔭 Building production-grade applications in Go, Java, and Kotlin
• 🌱 Exploring Rust for systems programming
• 👯 Open to collaborate on microservices, cloud architecture, and system design
• 💬 Ask me about: Go, Java, Kotlin, Spring Boot, AWS, Terraform, Solutions Architecture
• ⚡ Fun fact: I bridge legacy enterprise systems with modern cloud-native architectures