ALEXANDRE ALVES

• Improved reliability and maintainability of Go (Golang) REST APIs by increasing automated test coverage, strengthening documentation, and enforcing stricter code-quality, and linting standards.
• Delivered new capabilities to Go-based ETL workers, enhancing internal data pipelines, and ensuring consistent, high-volume data processing.
• Designed and implemented Python utilities for scalable data ingestion and migration, enabling smooth spreadsheet-to-database, and database-to-database data flows.

• Drove company-wide transitions to automated architectures using AWS Step Functions and Go, enhancing operational efficiency.
• Led the backend engineering team in migrating from REST to GraphQL, overseeing all phases from design to implementation.
• Developed a GraphQL API to streamline front-end interactions, reducing manual tasks for engineering teams.
• Implemented metrics and observability tools in Go, improving application performance monitoring.
• Created extensive documentation and workflows to facilitate knowledge sharing and best practices within the team.

Main Projects:

Trusted Sync:

A tool to sync data with the Student Information System (SIS) REST APIs.

Architecture:

• The backend applications were written entirely in Go (1.20+), and in their latest version deployed on AWS, structured in Lambda Functions and Step Functions, connected to an RDS database (Postgres), authenticating with JWT. The implementation of the API layer was built in GraphQL, serving an application in React.

Context:

This was the main project I worked on at the company, where I contributed to evolving a tool that was initially fully manual and operated exclusively by engineers. I helped transform it into a web-based application that could be used directly by the area’s stakeholders.

APIs in Go:

Architecture:

• Lambda functions written in Go (1.20+), in a serverless structure using AWS API Gateway, RDS database (Postgres), and JWT for the authentication.

Context:

There is no specific project to highlight here, but rather a pattern built together with the API team entirely in serverless, first with REST, and later the migration of the main services to GraphQL, where I had the opportunity to act as a team leader, being the "owner" of that effort.

GraphQL Migration:

This migration, where we improve response time through code refactorings done during the REST endpoint migration process, and work with feature flags, and a good dashboard to execute everything safely.

One thing to highlight here is the response time of the main listing UIs, as there was the introduction of a more refined pagination, which allowed flexibility in how calls were made.

• Led development of scalable web applications using modern frameworks and cloud technologies.
• Implemented automated testing strategies, improving code quality and reducing deployment time

• Maintained AWS Lambda functions, serving as background workers.
• Maintained Infrastructure as Code (IaC) using Terraform.
• Contributed to internal libraries written in Go.
• Designed and built a chat microservice in Golang to support millions of users, leveraging Redis features.

Main Projects:

Multi-User-Chat

Architecture.

• A Go-based microservice architecture consisting of workers and an API, managing chat rooms with Redis (AWS ElastiCache), used for message broadcasting and state management.

Context

• The lead engineer of the project is taking over from a concept started by one of the principal engineers to build an app in Go, using Redis for state management and message broadcasting.
• My mission was to start with a small proof of concept, studying Redis in depth to ensure integrity and performance in the interaction between users in a group chat.
• I first started with a small project, beginning with the basic premises for integration with clients. I met with other teams to design the integration and build the components that would serve as APIs and workers for the broadcast of the rooms, supporting Redis features such as "Transactions," "Pub/Sub," and "Streams" (to take advantage of the concept of consumer groups).

• Led the development of a robust search API from the ground up. Designed the indexing architecture, and developed a resilient API in Go to handle requests to Elasticsearch. Successfully supported an average throughput of 50k RPM, with response times under 100 ms.

Main Projects:

Catalog Search:

Architecture

• A set of Go applications built on an event-driven architecture, designed to index a product catalog into Elasticsearch.

Context

• I started this project alongside another senior engineer, with the mission of implementing it from scratch. Our first step was to understand the data sources and the key points of change within an existing architecture, which was originally built in PHP (using WordPress). An admin interface written in Python (Django) had recently been introduced as the first step in breaking down the PHP monolith, which was already facing scalability issues.

Proposed Solution

• Since the company already had cloud infrastructure at Google, we used "Pub/Sub" to broadcast the messages initially generated from Debezium (CDC, Change Data Capture), and a tool called Benthos to write ETLs, suggested by my teammate. After analysis, I saw that it could be of great help in achieving the objective more quickly, since Benthos was a mature enough tool for the purpose we initially had of performing simple operations on the message initially produced and aggregating some data from other APIs.
• The Go API was simple, serving the backward-compatible format of the WordPress app REST API. The migration of mobile applications was smooth. It was responsible for building the queries and retrieving data from ElasticSearch, using a caching strategy with Redis to avoid burdening the search.
• Over time, feature requests caused the architecture to expand, but it was easily extensible with the addition of new components, being well divided, with well-defined responsibilities.

• Evolution and maintenance of REST APIs in Go. Member of the squad responsible for the back-office application, for the control and customization of our white-label product.

Developed microservices for navigation, ranking, and relevance customization for the search engine, along with enhancing indexing workers. Utilized ElasticSearch 7+, and primarily worked with NodeJS, React, and Java.

Keeping the projects built previously on Go, and building APIs on the same platform.

• Member of the recommendation search team, working with Go and Python, and maintaining legacy systems on PHP frameworks. Configured CircleCI for deploying applications on Kubernetes.

• Developed a white-label chat commerce platform using React, React Native, and Node.js. Contributed across the entire stack, including setting up Docker images for deploying frontend and backend applications. Refactored the platform by migrating applications from Grails to Go, integrating Elasticsearch, RabbitMQ, and Redis.

As a direct employee of UOL, I managed the mobile app until April 2017. From May 2017, I joined the backend team, focusing on a microservice architecture, where I built microservices in NodeJS integrated with other systems via Apache Kafka, and created a REST API in Python using Flask to trigger segmented push notifications based on user profiles.

• Assigned to the UOL EdTech client, I managed the evolution and maintenance of a white-label corporate training mobile app using Java (JDK 8) and popular libraries like Retrofit, EventBus, and Glide. Additionally, I set up an automated application delivery pipeline with CircleCI, integrated into Bitbucket, significantly boosting the productivity of the Android development team.

• Support for projects developed for Brazil Port Terminal and Santos. Brazil using the C #, Java and SQL languages.