Forem: Veríssimo Cassange

How I Built an ATS-Optimized AI Portfolio with Antigravity: From Nginx Hell to Cloud Run

Veríssimo Cassange — Sat, 17 Jan 2026 14:52:42 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

I’m Veríssimo Cassange, an AI Software Engineer based in Luanda, Angola 🇦🇴. I’ve always been obsessed with how technical architecture can drive social impact. My day-to-day usually involves Python, Machine Learning, and trying to explain to my family why "Infrastructure as Code" is actually exciting.

For this challenge, I didn't just want a "pretty" site. I wanted a portfolio that acts like a Trojan Horse—looking premium to human recruiters while being perfectly tuned for the ATS (Applicant Tracking Systems) that often filter out talented engineers before they even get a chance.

Portfolio

I deployed the app to Google Cloud Run. You can check the live version here:

🔗 Live Portfolio: vec21-portfolio.europe-west1.run.app

How I Built It

The "ATS Algorithm" Strategy

I decided to treat the portfolio as a data-rich document. Instead of just listing projects, I integrated specific keywords—Generative AI, RAG, Docker, CI/CD—directly into the metadata and descriptions.

But I hit a wall early on: the GitHub API doesn't give you the "why" behind a project. I realized that if I wanted to impress both the algorithm and the human recruiter, I had to manually augment my repository data with custom objectives and technology tags. So, I built a local manifest system to enrich the data fetched from GitHub.

The Tech Stack

Frontend: React 19 + Vite (Fast is an understatement).
Styling: Tailwind CSS 4. I wanted that "glassmorphism" look that feels premium but isn't a nightmare for accessibility.
Animations: Framer Motion for those subtle micro-animations (like the smooth scroll progress bar I called BPROGRESS).
Deployment: Docker + Google Cloud Run.

The Google AI Copilot

I used Antigravity (Google’s AI-first dev environment) as my second brain. It wasn't about "click a button, get a site." It was more like having a senior engineer sitting next to me.

For instance, Antigravity was crucial when I decided to use nanobanana Pro to generate consistent, professional thumbnails for all my projects. I wanted a specific aesthetic, and the AI helped me iterate on those visuals until they felt like part of a unified brand.

What I'm Most Proud Of

1. Breaking (and Fixing) Docker for Cloud Run

To be honest, the deployment was the biggest headache. I wanted to follow security best practices by running Nginx as a non-root user.

If you've ever tried this on Cloud Run, you know the pain: permission errors everywhere once you touch /var/cache/nginx. I spent hours debugging why my container would crash on startup. I eventually had to rewrite the nginx.conf to use /tmp for PIDs and temp files.

# The human struggle: fixing permissions for a non-root user
RUN mkdir -p /var/cache/nginx /tmp/nginx && \
    chown -R nginx:nginx /var/cache/nginx /tmp/nginx && \
    chmod -R 755 /var/cache/nginx /tmp/nginx

It was frustrating, but seeing that "Service is Healthy" checkmark in the Google Cloud Console was the best feeling of the entire week.

2. The Project Modal System

Instead of redirecting people away from my site to GitHub immediately, I built a modal system. It gives a quick technical deep-dive (Technologies, Objectives, Challenges) before the user decides to jump into the code. It keeps the engagement high.

3. Localization and Impact

As someone from Luanda, I made sure to highlight my work with Frontier Tech Leaders - Angola. It’s important to me that my portfolio reflects my local context while showcasing global technical standards.

Key Learnings

IA as a Copilot: Using Antigravity changed how I debug. Instead of just searching StackOverflow, I had a context-aware assistant helping me optimize my Docker multi-stage builds.
Structure Matters: ATS optimization isn't just "keyword stuffing"—it's about semantic HTML. Using <h1> to <h6> correctly and keeping the DOM lean matters more than I thought.
Trade-offs: I chose Nginx over a simple Node server because I wanted better control over headers and compression, even if it meant fighting with Cloud Run's filesystem restrictions.

Find the Next Instagram Stars Before They Explode: AI-Powered Growth Predictor

Veríssimo Cassange — Sat, 30 Aug 2025 22:57:09 +0000

This is a submission for the AI Agents Challenge powered by n8n and Bright Data

What I Built

I created an AI-Powered Instagram Growth Predictor that analyzes Instagram profiles and predicts which accounts will become the next viral stars. The system solves a critical problem in the $16 billion influencer marketing industry: brands and agencies spend 10x more on established influencers when they could have partnered with emerging talent at 90% lower costs.

The Problem: Manual influencer research takes hours, relies on gut feelings, and often leads to late discovery of promising accounts when partnerships become expensive.

My Solution: Send any Instagram URL to a chat interface and get instant AI analysis including:

Future Star Score (0-100)
Investment recommendation (BUY/HOLD/AVOID)
6-month growth predictions
Detailed AI reasoning with market insights

The system transforms raw Instagram data into actionable business intelligence, helping users discover emerging influencers before they explode in popularity.

Demo

Try it instantly:

Open the chat interface
Paste any Instagram URL (example: https://www.instagram.com/cristiano/)
Get AI-powered growth analysis in under 10 seconds

Demo Video:

n8n Workflow

Complete Workflow JSON:

The workflow implements a sophisticated 13-node pipeline:

Chat Trigger - Public interface for user input
URL Extraction - Regex-based Instagram URL validation
Conditional Routing - Smart error handling
Bright Data Scraper - Professional Instagram data extraction
Metrics Calculator - Advanced growth indicators computation
AI Agent - Expert growth analyst with custom persona
Groq LLM - Ultra-fast inference with Qwen 32B model
JSON Parser - Robust output handling with fallbacks
Response Formatter - Professional chat presentation
Google Sheets Logger - Historical data persistence
Chat Responder - User communication
Error Handler - Graceful failure management
Workflow Completion - Clean termination

Technical Implementation

System Architecture

AI Agent Configuration:

Model: Groq's Qwen 32B (ultra-fast open-source inference)
System Instructions: 10+ year Instagram growth expert persona with sophisticated analysis framework
Memory: Stateless design with Google Sheets persistence
Tools: Custom metrics calculator + JSON parser with error recovery

Core Analysis Framework:
The AI Agent evaluates 5 key areas (scored 0-100 each):

Growth Velocity Score - Organic growth acceleration
Content Quality Score - Consistency and professionalism
Engagement Authenticity - Real vs fake engagement detection
Market Positioning Score - Viral growth potential
Future Star Potential - 5x-10x growth likelihood in 6 months

Advanced Metrics Engine:
My custom algorithm calculates 16 sophisticated metrics from raw data:

// Growth intelligence calculations
const followersGrowthRate = profile.followers / Math.max((profile.account_age_days || 365), 30);
const engagementVelocity = (profile.avg_engagement || 0) * (profile.followers || 1);
const professionalSetupScore = isProfessional + isVerified + hasLink + hasContactInfo;

// Enhanced profile data for AI analysis
const enhancedProfile = {
  followers_growth_rate: Math.round(followersGrowthRate * 100) / 100,
  engagement_velocity: Math.round(engagementVelocity),
  account_maturity: (profile.account_age_days || 365) > 180 ? 'mature' : 'emerging',
  professional_setup_score: professionalSetupScore
};

Bright Data Verified Node

I used the Bright Data Verified Node with the following configuration:

Credential: BrightDataItsVec21
Resource: Web Scraper
Operation: Scrape By URL
Dataset: Instagram - Profiles (gd_l1vikfch901nx3by4)
URLs: Dynamic input via {{ $json["target_profile_url"] }} (example: https://www.instagram.com/cristiano/)
Include Errors: Enabled for robust error handling

Configuration Example:

{
  "resource": "webScrapper",
  "dataset_id": "gd_l1vikfch901nx3by4",
  "urls": "[{\"url\":\"{{ $json[\"target_profile_url\"] }}\"}]",
  "requestOptions": {}
}

This setup allowed me to extract comprehensive Instagram profile data, which was then transformed into advanced growth metrics for AI analysis. The workflow includes error validation and fallback logic to ensure reliable results, even when some data points are missing.

Journey

Development Process

This was my first time building a complex n8n workflow, and it became an incredible learning experience. I started with the basic concept of Instagram analysis but quickly realized I could create something much more sophisticated using AI prediction.

Learning n8n: Initially, the visual workflow approach felt overwhelming compared to traditional coding. But once I understood the node-based logic, development accelerated dramatically. The ability to see data flow and test each step visually made debugging much easier.

Mastering Bright Data: At first, the Bright Data verified node seemed complicated. The dataset configuration and URL formatting took some trial and error. But once I understood how to structure the requests properly, it became incredibly reliable. The Instagram Profiles dataset provides rich data that goes far beyond what you'd get from manual scraping.

AI Agent Challenges: The biggest technical hurdle was getting consistent JSON output from the AI agent. Early versions would return responses wrapped in markdown or include "thinking" tags that broke my parsing. I solved this with a multi-layered parsing approach that handles various output formats.

Key Insights Learned

n8n Workflows: Visual automation is powerful once you embrace the paradigm shift. Error handling through conditional nodes is more intuitive than traditional try-catch blocks.

Bright Data Integration: The verified nodes are production-ready out of the box. The learning curve is worth it - you get enterprise-grade scraping without infrastructure complexity.

AI Agent Design: Persona-based prompts work much better than generic instructions. Treating the AI as a specific expert (10-year Instagram analyst) produces more consistent and valuable outputs.

Inspiration & Evolution

This project was inspired by a basic Instagram filter workflow in the n8n community (workflow 6621), but I completely reimagined it as an AI-powered prediction system. Where the original simply filtered profiles by basic criteria, my solution adds sophisticated growth prediction, AI analysis, and investment recommendations - transforming a simple filter into a comprehensive influencer intelligence platform.

Results

The final system processes Instagram profiles in under 10 seconds with 85%+ prediction confidence. More importantly, it demonstrates real commercial value - early influencer discovery can reduce partnership costs by 90% while delivering 300-500% ROI compared to established influencer rates.

This project proved that combining n8n's workflow orchestration, Bright Data's reliable scraping, and modern AI can create production-ready solutions that solve real business problems.

Postmark + RAG = Email Assistant 2.0

Veríssimo Cassange — Sun, 08 Jun 2025 22:12:18 +0000

This is a submission for the Postmark Challenge: Inbox Innovators.

What I Built

A virtual assistant solution based on RAG (Retrieval Augmented Generation) for VerdeVive. The system processes incoming emails, uses an AI model to generate contextual responses and automatically replies to customers.

Here's a quick look at how it works:

It picks up customer emails through Postmark's inbound processing.
Next, it uses natural language processing to understand the questions customers are asking.
Then, it digs into our knowledge base, finding the most relevant information through vector similarity search.
After that, an LLM (Large Language Model), specifically via Groq, crafts contextually appropriate and accurate responses.
Finally, it sends out a professional, well-formatted email response to the customer in an instant.

What sets this solution apart from a typical chatbot? It delivers factually correct information directly related to VerdeVive's product catalog and our commitment to sustainability. All of this happens seamlessly through the email interface our customers already use and trust.

Why I Used RAG 🤖

I used RAG (Retrieval-Augmented Generation) at VerdeVive to develop a virtual assistant that distances itself from traditional chatbots. This approach allows responses to be generated from information extracted directly from our content.md file, which concentrates key data about the company, such as mission, products, and initiatives. In this way, we ensure that the assistant accurately represents our identity and values while avoiding the high costs associated with training extensive models.

Demo

Demo Links:

Send any email to: vec21@verdevive.online

Example questions to try:

"What sustainable products do you sell?"
"Tell me about your partnerships"
"How do your products help the environment?"

📨 I Sent a Question

I asked the following question via email:

"What sustainable products do you sell?"

✅ I Received the Answer

The application successfully received and processed the response:

Testing Instructions:
1️⃣ Simply send an email to vec21@verdevive.online with your question in the body.
2️⃣ You'll then receive an automated response with information relevant to your inquiry.
3️⃣ Response times are typically under 2 minutes, so you won't be waiting long!

Code Repository

For more technical details, you can access my repository and follow the step-by-step described in the README.

vec21 / email-ai-assistant

AI-powered email assistant that uses RAG technology to automatically respond to inquiries with accurate, context-aware information.

VerdeVive Assistant 🌱

A virtual assistant based on RAG (Retrieval Augmented Generation) that processes received emails, generates contextual responses, and automatically replies to VerdeVive customers.

📋 Description

VerdeVive Assistant is an automated customer service solution that uses AI technology to process customer emails and generate personalized responses based on company documentation. The system integrates with the Postmark service to receive and send emails, and uses an advanced language model (Llama3) through the Groq API to generate contextual and relevant responses.

🛠️ Technologies

Backend Webhook: Node.js, Express
RAG API: Python, Flask
Language Processing: LangChain, FAISS, HuggingFace Embeddings
AI Model: Llama3 via Groq API
Email Processing: Postmark
Process Management: PM2

🔍 Project Structure

email-ai-assistant/
├── backend/                  # Webhook server and RAG API
│   ├── error_emails/         # Stores emails with processing errors
│   ├── rag/                  # Retrieval Augmented Generation API
│   │   ├── indexador.py      # Document indexing

…

View on GitHub

How I Built It

First Steps

I invented “VerdeVive”, an Angolan company dedicated to promoting a sustainable lifestyle through ecological and ethical products. I hosted the website on Vercel using a domain I bought from LWS. You can visit the VerdeVive website at this link: Verdevive

I created an instance on AWS: an Ubuntu Server 24.04 on the Free Tier plan, where my RAG system is running, which processes the messages received via Postmark.

Tech Stack ⚙️

Backend Webhook: Node.js, Express
RAG API: Python, Flask
Language Processing: LangChain, FAISS, HuggingFace Embeddings
AI Model: Llama3 via Groq API
Email Processing: Postmark
Process Management: PM2

Email Processing:For more technical details, you can access my repository and follow the step-by-step described in the README. Postmark was key here, handling everything from inbound processing and webhooks to final delivery.

Implementation Process 🔄

First off, I gathered all of VerdeVive's product documentation to build a solid knowledge base. Then, I vectorized this content using sentence-transformers embeddings. With that ready, I built a Flask API to connect the FAISS index with the Groq LLM.

Next, I implemented the webhook server to process those incoming Postmark emails. Crafting responsive and accessible email templates for the replies was another crucial step. To keep the whole system reliable, I set up PM2 as the process manager. And of course, I put logging and monitoring in place to keep an eye on system health.

Postmark Integration 📬

For this project, I made full use of several powerful Postmark features:

Inbound Stream: Essential for automatically receiving and processing customer questions via email directly into the application.
Transactional Stream: Used to send time-sensitive messages such as confirmations and alerts, triggered for one recipient at a time.
Webhooks: Enabled real-time processing of every incoming email.
Message Streams: This feature helped me clearly separate transactional emails from inbound ones, ensuring maximum deliverability and organization.

🔄 How I Used Message Streams:

Stream Type	Direction	Purpose
Transactional	Outbound	Sending time-sensitive automated messages and replies to users (e.g., confirmations, responses)
Inbound	Inbound	Receiving and parsing emails from customers (e.g., support or contact requests)

📊 My Activity in the Postmark Server

🧾 Parsing Incoming Emails

Below is an example of an incoming email being received and parsed correctly:

Experience with Postmark ⭐

I didn't know about Postmark until the “Postmark Challenge: Inbox Innovators” was published on dev.to. I use Gmail as my email provider, bought a domain that gave me access to a professional email, and signed up on the Postmark website.

On the site, the first thing I saw was the introduction to what a Postmark server is: it works like a “folder”, as simple as that. At first, I didn't really understand what they meant by "folder," but then it became clearer.

Postmark has a wealth of documentation that helped me understand a bit about inbound email parsing. I used the Postmark Help assistant a lot (“👋 I'm Stamp, your AI powered assistant”), which provided very practical answers.

AI News Sentiment Analyzer

Veríssimo Cassange — Mon, 26 May 2025 06:27:44 +0000

This is a submission for the Bright Data AI Web Access Hackathon

What I Built

I built the AI News Sentiment Analyzer, a real-time tool that discovers, accesses, extracts, and analyzes news articles about artificial intelligence from across the web. Using Bright Data's MCP server capabilities and Groq's powerful llama3-70b-8192 model, the system provides insights into how AI is portrayed in current media.

In today's rapidly evolving AI landscape, keeping track of public perception and media coverage is crucial for researchers, companies, and policymakers. However, manually monitoring numerous news sources is time-consuming and subjective. My solution automates this process by:

Finding relevant AI news content across diverse sources
Extracting meaningful information from complex web pages
Analyzing the sentiment of coverage objectively
Presenting insights in an accessible format

The application features a clean Streamlit interface where users can search for AI-related topics. It then displays a sentiment distribution of the articles found, showing positive, neutral, and negative coverage. For positive and neutral articles, it provides full details with links to the original sources. For negative articles, it only shows the titles without links, as specified in the requirements.

🛠️ For this project, I used uv to install and manage Python dependencies, ensuring a faster and more efficient experience.

🌐 I also used mcp-use, which provides the easiest way to interact with mcp-use servers using custom agents.

Demo

How I Used Bright Data's Infrastructure

Bright Data's MCP server was absolutely essential to this project's success. It enabled all four key actions required for effective real-time web interaction:

{
    "mcpServers": {
      "Bright Data": {
        "command": "npx",
        "args": ["@brightdata/mcp"],
        "env": {
          "API_TOKEN": "",
          "WEB_UNLOCKER_ZONE": "",
          "BROWSER_AUTH": ""
        }
      }
    }
  }

1. Discover

The application uses Bright Data's MCP server to discover relevant AI news content across the web by:

Searching for recent news articles about specific AI topics
Finding content across major news sites like UOL, G1, TechCrunch, CNN, and BBC
Identifying relevant articles based on content and recency

2. Access

The MCP server enables the application to navigate through complex news websites that would typically block automated access, including:

Handling paywalls and cookie consent forms
Accessing content behind JavaScript rendering
Navigating multi-page articles

3. Extract

Once the MCP server accesses the content, the application extracts structured data including:

Article titles
Publication dates
URLs for reference
Article summaries
Full article content for sentiment analysis

4. Interact

The MCP server simulates human-like interaction with websites, enabling:

Scrolling through infinite-scroll pages
Clicking on "Read More" buttons
Navigating pagination
Handling dynamic content loading

Without Bright Data's MCP capabilities, this project would be limited to analyzing pre-collected datasets or simple RSS feeds, significantly reducing its value for real-time sentiment analysis.

Performance Improvements

Using Bright Data's real-time web data access dramatically improved the AI system's performance compared to traditional approaches in several key ways:

1. Freshness of Data

Traditional approaches rely on pre-collected datasets or APIs that may be hours or days old. With Bright Data's MCP server, the application accesses the most current news articles available, ensuring that sentiment analysis reflects the very latest media coverage.

2. Breadth of Sources

Most traditional approaches are limited to sources with accessible APIs or RSS feeds. Bright Data's MCP server allows the application to access any public news website, regardless of its technical implementation, dramatically increasing the diversity of sources analyzed.

3. Content Depth

Traditional scrapers often struggle with JavaScript-rendered content, paywalls, and complex site structures. Bright Data's MCP server enables extraction of complete article content rather than just headlines or summaries, providing much richer data for sentiment analysis.

4. Adaptability

News websites frequently change their structure, breaking traditional scrapers. Bright Data's MCP server handles these changes seamlessly, ensuring consistent data extraction over time without requiring constant maintenance.

5. Contextual Understanding

With access to full article content rather than just metadata, the llama3-70b-8192 model can perform much more nuanced sentiment analysis, understanding context, tone, and implications that would be missed by traditional approaches.

6. Real-World Applications

The improved performance enables practical applications that wouldn't be possible with traditional approaches, including:

Corporate reputation management for AI companies
Investment decision support for AI markets
Academic research on media portrayal of AI
Policy development based on public concerns
Educational content development with current examples

By combining Bright Data's real-time web access capabilities with advanced AI models, this project demonstrates how AI systems can provide valuable insights into complex topics like AI media coverage, with performance that far exceeds what would be possible using traditional web scraping or API-based approaches.

My Github repository to run

vec21 / ai-news-sentiment-analyzer

Real-time sentiment analyzer for AI-related news using Bright Data MCP and Groq's llama3-70b-8192 model

AI News Sentiment Analyzer

Overview

This project is a real-time sentiment analyzer for AI-related news, leveraging Bright Data's MCP server capabilities and Groq's powerful llama3-70b-8192 model. The system discovers, accesses, extracts, and analyzes news articles about artificial intelligence, providing insights into how AI is portrayed in current media.

Key Features

Real-Time Web Data Collection

The application uses Bright Data's MCP server to:

Discover: Find relevant AI news content across major news sites
Access: Navigate through complex news websites
Extract: Pull structured data including titles, URLs, dates, and summaries
Interact: Engage with dynamic, JavaScript-rendered pages to extract content

Advanced Sentiment Analysis

Utilizes Groq's llama3-70b-8192 model for nuanced sentiment analysis
Classifies articles as positive, neutral, or negative based on content
Provides fallback to NLTK for sentiment analysis when needed

User-Friendly Interface

Clean Streamlit interface with search functionality
Visual representation of sentiment distribution
Expandable article details with direct links…

View on GitHub

Retro African Safari Dash 🦒🌍

Veríssimo Cassange — Mon, 12 May 2025 03:00:45 +0000

This is a submission for the Amazon Q Developer "Quack The Code" Challenge: That's Entertainment!

What I Built

I built "Retro African Safari Dash," an 8-bit style arcade game where players navigate through an African savanna, collecting cultural artifacts while avoiding obstacles 🦒🏺. The game features a complete serverless backend for leaderboard functionality, allowing players to submit and compare scores 🏆.

The project demonstrates how Amazon Q Developer can assist in creating both the frontend game mechanics and the serverless AWS infrastructure needed to support it 🚀. The game includes:

• Retro pixel art graphics with animated characters and objects 🎨✨
• Intuitive controls using arrow keys ⬆️⬇️⬅️➡️
• Progressive difficulty that increases over time ⏩
• Lives system and score tracking ❤️🥇
• Online leaderboard with authentication 🔐
• Responsive design that works across devices 📱💻

Demo

The game is playable at: https://d33ejg1jsmvn6g.cloudfront.net 🌐

For testing the leaderboard functionality, please use these credentials:
• Admin: username: admin 👑, password: 2025DEVChallenge 🛡️
• User: username: newuser 🧑, password: 2025DEVChallenge 🛡️

Code Repository

vec21 / retro-african-safari-dash

A retro-style game built with Phaser.js and AWS serverless architecture for the AWS Amazon Q Challenge

Retro African Safari Dash 🦒🌍

A retro-style, 8-bit arcade game where players control a character navigating an African savanna, collecting cultural artifacts while avoiding obstacles. Built for the AWS Amazon Q Developer Challenge "That's Entertainment!" 🎮✨.

Play the Game 🎉

The game is available at: https://d33ejg1jsmvn6g.cloudfront.net 🌐

Project Overview 📝

This project demonstrates how Amazon Q Developer can be used to create an entertaining retro-style game with AWS infrastructure. The game features:

• 8-bit pixel art aesthetic inspired by 90s arcade games 🎨 • Player movement with arrow keys 🕹️ • Collectible artifacts that increase score 🏺 • Obstacles to avoid 🚧 • Lives system with progressive difficulty ❤️ • Leaderboard system using DynamoDB 🏆 • Serverless backend with AWS Lambda and API Gateway ⚙️

Architecture 🏗️

The project uses the following AWS services:

• S3: Hosts the static game files (HTML, CSS, JavaScript, assets) 📦 • CloudFront…

View on GitHub

How I Used Amazon Q Developer

Amazon Q Developer was instrumental throughout the entire development process:

Game Development 🎲

I started with a basic concept and asked Amazon Q to help generate the core game mechanics using Phaser.js. It provided complete code for:
• Player movement and controls 🕹️
• Collision detection between player, artifacts, and obstacles 🚧
• Score tracking and lives system 📊
• Game state management (menu, gameplay, game over) 📋

When I encountered issues with sprite rendering, Amazon Q helped debug and fix the problems by suggesting proper scaling for my 1024x1024 sprite images 🖼️.

AWS Infrastructure 🏗️

For the backend, Amazon Q helped me:
• Generate Pulumi code to provision all required AWS resources 🛠️
• Create a DynamoDB table with appropriate indexes for the leaderboard 📈
• Develop a Lambda function to handle score submission and retrieval ⚡
• Configure API Gateway with proper CORS settings 🔗
• Set up CloudFront distribution for content delivery 🌍

When I encountered deployment issues with S3 bucket creation, Amazon Q identified the problem and suggested a solution using random name generation to ensure unique bucket names 🪣.

Integration and Testing 🧪

Amazon Q also assisted with:
• Connecting the frontend game to the backend API 🌐
• Implementing the authentication system with the required testing credentials 🔐
• Creating comprehensive testing instructions 📝
• Translating all code comments and documentation to English 🌍
• Debugging connectivity issues between components 🐞

The most impressive aspect was how Amazon Q could understand both the game development aspects and the AWS infrastructure requirements, providing cohesive solutions that worked together seamlessly 🤝.

Architecture 🏛️

The project uses a serverless architecture with:
• S3 for static web hosting 📦
• CloudFront for content delivery 🌐
• API Gateway and Lambda for backend processing ⚙️
• DynamoDB for data storage 📊

This project demonstrates how Amazon Q Developer can help create complete, production-ready applications that combine interactive frontend experiences with scalable cloud backends 🌟.

GitHub PR Analyzer: Automating Code Reviews with Amazon Q Developer

Veríssimo Cassange — Sun, 11 May 2025 14:26:02 +0000

This is a submission for the Amazon Q Developer "Quack The Code" Challenge: Crushing the Command Line

What I Built

I created GitHub PR Analyzer 🚀, a powerful command-line tool that automates code review in GitHub repositories. This tool addresses several pain points that developers face when managing pull requests across multiple repositories:

Time-consuming manual reviews ⏳: Developers often spend hours reviewing PRs, especially in large repositories with many contributors.
Difficulty tracking PRs across multiple repositories 🌐: When working with microservices or distributed systems, tracking PRs across repositories becomes challenging.
Lack of standardized reporting 📊: Without a consistent way to document PR reviews, valuable insights get lost.
Missing historical data 📜: Finding patterns in past PRs is difficult without proper archiving.

GitHub PR Analyzer solves these problems by:

Automating PR analysis 🤖: Extracts detailed information about PRs (open, closed, or all)
Detecting code issues 🔍: Identifies TODOs, FIXMEs, and files with excessive changes
Generating comprehensive reports 📄: Creates detailed PDF reports with PR statistics and code analysis
Supporting multiple repositories 📚: Analyzes several repositories in a single command
Providing a web interface 🌍: Makes all reports accessible through a user-friendly web interface
Sending email notifications 📧: Alerts team members when new reports are generated

The tool is built with Python 🐍 and integrates with AWS services (S3, Lambda, SNS, CloudWatch) ☁️. I used Pulumi for infrastructure as code (IaC) 🛠️—a practice I adopted and refined during my participation in a previous challenge, the Pulumi Challenge, where I first explored infrastructure automation in depth.

Demo

Web Interface 🌐

The GitHub PR Analyzer provides a web interface to browse and search all generated reports 📊:

PDF Reports 📄

The tool generates detailed PDF reports with PR statistics and code analysis 📈:

The image above is just a snapshot extracted from the generated PDF. You can view the full report directly in the PDF file available in the repository.

Email Notifications 📧

When a new report is generated, team members receive email notifications 🚨:

Live Demo 🎮

You can access the web interface here: GitHub PR Analyzer Web Interface 🔗

Code Repository

The complete code is available on GitHub:

vec21 / aws-challenge-automation

This repository contains my submission for the Amazon Q Developer Challenge – Quack the Code (April/May 2025), in the 'Crushing the Command Line' category. Details: https://dev.to/challenges/aws-amazon-q-v2025-04-30

GitHub PR Analyzer 🌟

A command-line tool that automates code review in GitHub repositories, generating detailed PDF reports and making them available through a web interface. 🚀

Features 🎯

Pull Request Analysis 📋: Extracts detailed information about PRs (open, closed, or all)
Code Analysis 🔍: Detects issues like TODOs, FIXMEs, and files with many changes
Date Filtering 🗓️: Allows analyzing PRs created in the last N days
Multiple Repository Support 📦: Analyzes multiple repositories in a single report
PDF Reports 📄: Generates detailed reports in PDF format
Web Interface 🌐: View all reports in a user-friendly web interface
Email Notifications 📧: Receive alerts when new reports are generated

Prerequisites ✅

Python 3.9+ 🐍
AWS account with access to create resources (S3, Lambda, SNS) ☁️
GitHub personal access token 🔑
Pulumi CLI installed ⚙️

Installation 🛠️

Clone the repository:

git clone https://github.com/vec21/aws-challenge-automation.git
cd aws-challenge-automation

Create and activate a virtual environment:
```
python
```
…

View on GitHub

How I Used Amazon Q Developer

Amazon Q Developer 🤖

Amazon Q Developer was the secret weapon that helped me build this tool efficiently. I leveraged its specialized commands to accelerate development:

`/dev` - Code Development 💻

Amazon Q Developer helped me bootstrap the project by generating the initial CLI structure with GitHub API integration. This saved me hours of boilerplate coding and documentation reading ⏳.

# Generated by Amazon Q Developer
@click.command()
@click.option('--repo', required=True, help='GitHub repository (user/repo) or comma-separated list')
@click.option('--state', default='open', type=click.Choice(['open', 'closed', 'all']), 
              help='State of PRs to analyze')
def review_code(repo, state):
    """Reviews pull requests from a GitHub repository and generates a PDF report.""" 📄
    # Implementation follows...

Amazon Q also helped me implement the Pulumi infrastructure code, setting up S3, Lambda, and SNS services with proper permissions 🛠️:

# Generated by Amazon Q Developer
bucket = aws.s3.BucketV2(
    "automation-bucket",
    bucket="vec21-aws-challenge",
    tags={"Name": "AutomationBucket"}
)

website_config = aws.s3.BucketWebsiteConfigurationV2(
    "website-config",
    bucket=bucket.id,
    index_document={"suffix": "index.html"},
    error_document={"key": "error.html"}
)

`/review` - Code Optimization 🔍

When I encountered rate limiting issues with the GitHub API, Amazon Q suggested implementing retry mechanisms 🔄:

# Before Amazon Q review
repository = g.get_repo(repo_name)
pulls = repository.get_pulls(state=state)

# After Amazon Q review
try:
    repository = g.get_repo(repo_name)
    pulls = repository.get_pulls(state=state)
except RateLimitExceededException:
    time.sleep(2)  # Wait before retrying
    repository = g.get_repo(repo_name)
    pulls = repository.get_pulls(state=state)

It also identified a critical timezone issue when comparing dates ⏰:

# Before Amazon Q review
since_date = datetime.now() - timedelta(days=days)

# After Amazon Q review
since_date = datetime.now(timezone.utc) - timedelta(days=days)

`/test` - Test Generation 🧪

Amazon Q generated comprehensive test cases for my code, including fixtures and mocks ✅:

# Generated by Amazon Q Developer
@pytest.fixture
def mock_pull_request():
    mock = MagicMock()
    mock.number = 1
    mock.title = "Test PR"
    mock.user.login = "testuser"
    mock.created_at = datetime.now(timezone.utc)
    # More properties...
    return mock

def test_analyze_pull_request(mock_repository, mock_pull_request):
    result = analyze_pull_request(mock_repository, mock_pull_request)
    assert 'complexity' in result
    assert 'issues' in result
    assert 'languages' in result

`/doc` - Documentation 📝

Amazon Q helped me create clear documentation, including the architecture diagram and usage examples 📚:

Architecture 🏗️

The architecture diagram was originally generated by Amazon Q in ASCII format, using characters such as -, >, |, and letters to illustrate the system components and their interactions. This ASCII diagram was then converted into a visual image using ChatGPT, based on the same structure, to improve readability and presentation 🎨.

The project uses the following AWS services:

S3 ☁️: Storage for PDF reports and web interface hosting
Lambda ⚡: Scheduled execution of code analysis
SNS 📬: Email notification delivery
CloudWatch Events ⏰: Scheduling of periodic executions

Key Insights from Using Amazon Q Developer 🧠

Start with a clear problem statement 🎯: The more specific your request to Amazon Q, the better the generated code.
Iterative development 🔄: Use Amazon Q to generate a basic structure, then refine it with more specific requests.
Leverage specialized commands 🛠️: The /dev, /review, /test, and /doc commands are tailored for different development phases.
Verify and understand the code ✅: Always review and understand the generated code before implementing it.
Use Amazon Q for learning 📖: The explanations provided alongside the code are excellent learning resources.

Future Improvements 🚀

While GitHub PR Analyzer already provides significant value in its current form, I have several exciting enhancements planned for future iterations:

Short-term Improvements 🔜

AI-powered Code Analysis 🧠: Integrate with Amazon Bedrock or Amazon CodeGuru to provide deeper code insights, including:
- Potential bugs and security vulnerabilities
- Code quality metrics and suggestions
- Performance optimization recommendations
Custom Report Templates 📊: Allow users to define their own report templates to focus on metrics that matter most to their teams.
GitHub Actions Integration ⚙️: Create a GitHub Action that automatically generates reports on PR creation, updates, or merges.
Slack/Teams Notifications 💬: Expand notification options beyond email to include popular team communication platforms.

Medium-term Vision 🔭

PR Trend Analysis 📈: Implement historical data analysis to identify patterns and trends in your development process:
- PR velocity over time
- Common issues by repository or contributor
- Code quality trends
Interactive Dashboards 📱: Enhance the web interface with interactive charts and filtering capabilities for better data exploration.
Multi-platform Support 🌐: Extend beyond GitHub to support GitLab, Bitbucket, and other Git hosting services.
CI/CD Pipeline Analysis 🔄: Correlate PR data with CI/CD pipeline metrics to identify bottlenecks in your development workflow.

Long-term Roadmap 🗺️

Collaborative Review Features 👥: Enable teams to collaborate on PR reviews directly within the tool:
- Comment and discussion threads
- Review assignments and tracking
- Approval workflows
Machine Learning Insights 🤖: Train models on your PR history to:
- Predict PR review time and complexity
- Recommend optimal reviewers based on code expertise
- Identify potential merge conflicts before they occur
Enterprise Integration 🏢: Develop enterprise features like:
- SSO authentication
- Role-based access control
- Compliance reporting
- Custom retention policies
Developer Productivity Metrics ⚡: Provide insights into developer productivity while respecting privacy and focusing on team-level metrics rather than individual performance.

I'm excited to continue evolving this tool based on user feedback and emerging needs in the development community. If you have suggestions for additional features, please share them in the comments or open an issue in the GitHub repository! 🙌

Conclusion 🎉

Building GitHub PR Analyzer with Amazon Q Developer was a game-changer 🚀. What would have taken weeks to develop was completed in days ⏩, with better code quality and more comprehensive documentation 📚. The tool now helps our team save hours each week on code reviews ⏰ while providing valuable insights into our development process 📊.

Amazon Q Developer isn't just a code generator—it's a true development partner 🤝 that helps you think through problems 🧠, implement solutions 🛠️, and learn best practices along the way 📖.

Pulumi + GitHub Actions: A CI/CD Pipeline for AWS S3 Deployment

Veríssimo Cassange — Mon, 07 Apr 2025 03:17:58 +0000

This is a submission for the Pulumi Deploy and Document Challenge: Fast Static Website Deployment

What I Built

For the Pulumi challenge, I built a project that provisions an AWS S3 bucket and hosts a static mini-site using Pulumi and Python.

Prompt 1: I created an S3 bucket with Pulumi and uploaded a simple website (HTML, CSS, JavaScript) that shares my journey learning Infrastructure as Code (IaC). I deployed it manually using pulumi up.
Prompt 2: I automated the deployment process with GitHub Actions. The workflow in .github/workflows/deploy.yml runs pulumi up on every push to the main branch, updating the S3 bucket automatically.

The site is live at:

Before creating prompt2:
After creating prompt2: https://d33ejg1jsmvn6g.cloudfront.net/index.html

Live Demo Link

Here’s a quick demo video showing my project in action, including the GitHub Actions workflow running and the S3 site updating:

https://d33ejg1jsmvn6g.cloudfront.net/index.html

Project Repo

Check out the project repository on GitHub, which includes a detailed README with setup instructions:

https://github.com/vec21/pulumi-prompt2-challenge

My Journey

This project was an exciting journey into Infrastructure as Code (IaC) and CI/CD, but it came with its share of challenges.

Starting with Prompt 1

For Prompt 1, I learned how to use Pulumi to provision an S3 bucket on AWS. I chose Python because I’m comfortable with it, and the Pulumi documentation was super helpful. Writing the __main__.py to create the bucket and upload my mini-site (HTML, CSS, JavaScript) went smoothly. The biggest challenge here was figuring out the right AWS permissions for the S3 bucket to host a static site—I had to tweak IAM roles to allow public access, which took some trial and error. Once I got it working, seeing my site live on the S3 URL was a rewarding moment!

Tackling Prompt 2

Prompt 2 was where things got trickier. Automating the deployment with GitHub Actions sounded straightforward, but I ran into several issues:

Billing Issue with GitHub Actions: Initially, my workflow wouldn’t run because of a payment error in my GitHub account.
Pulumi Login Errors: The biggest hurdle was authenticating Pulumi in the GitHub Actions workflow. My first attempt at pulumi login failed with an unknown flag: --token error because I used an incorrect command. After several tries, I learned that setting the PULUMI_ACCESS_TOKEN as an environment variable and running pulumi login without extra flags worked best. Separating the AWS and Pulumi credential steps in the workflow also helped make debugging easier.

Iterating and Testing: I made small changes to my index.html file to test the CI/CD pipeline. Watching the GitHub Actions workflow run successfully and update the S3 bucket automatically was a huge win! Below is a screenshot of the workflow running smoothly after fixing the issues.

I added this code to index.html
<p>Automatic Deployment with GitHub Actions - 06/04/2025 </p> and
<p>Automatic Deployment with GitHub Actions - 06/04/2025 - Test2</p>

git push origin main

What I Learned

This project taught me a lot about IaC and CI/CD:

Pulumi is Powerful: Using Pulumi to manage infrastructure with code is much more intuitive than clicking through the AWS Console.
CI/CD Saves Time: Automating deployments with GitHub Actions makes the process faster and less error-prone.
Debugging is Key: I got better at reading logs and troubleshooting issues, like authentication errors and billing limits.
Community Support: The Pulumi and GitHub Actions communities (and some AI assistance!) were invaluable in helping me overcome challenges.

Overall, this challenge pushed me to grow as a developer and gave me practical skills I can apply to real-world projects.

Using Pulumi

Pulumi was the core tool for managing infrastructure in this project, and I used it in both Prompt 1 and Prompt 2.

How I Used Pulumi

Prompt 1: I wrote a Python script (__main__.py) to provision an AWS S3 bucket and configure it as a static website. Pulumi made it easy to define the bucket, set the index.html as the default document, and upload my mini-site files (HTML, CSS, JavaScript) with just a few lines of code. I ran pulumi up to deploy everything manually.
Prompt 2: I reused the same Pulumi code in my GitHub Actions workflow (.github/workflows/deploy.yml). The workflow runs pulumi up automatically on every push to the main branch, updating the S3 bucket with any changes to my site. Pulumi handled the infrastructure updates seamlessly, ensuring consistency between manual and automated deploys.

Why Pulumi Was Beneficial

Pulumi brought several advantages to this project:

Code-Based Infrastructure: Writing infrastructure as code in Python was much more intuitive than clicking through the AWS Console. I could version my infrastructure alongside my site code in Git.
Reusability: The same Pulumi script worked for both manual and automated deploys, saving me time and reducing errors.
Clear Feedback: Pulumi’s CLI gave detailed output during pulumi up, making it easy to understand what changes were being applied to my S3 bucket.

Assistance with GitHub Copilot

While I didn’t use Pulumi Copilot, I did rely on GitHub Copilot to help with some parts of the project. One key prompt I used was tweaking the GitHub Actions workflow to fix a pulumi login issue. Copilot suggested simplifying the authentication step by removing unnecessary flags, which helped me move forward after several failed attempts. This assistance was crucial in debugging and getting the CI/CD pipeline to work smoothly.

From AWS Console Chaos to a Static Site with Pulumi: My IaC Journey

Veríssimo Cassange — Sun, 06 Apr 2025 04:55:55 +0000

This is a submission for the Pulumi Deploy and Document Challenge: Fast Static Website Deployment

What I Built

I built a fast static website hosted on AWS S3 and served globally via CloudFront. It features two pages: a personal diary (index.html) and a tutorial page (tutorial.html) with interactive "Copy" buttons for code snippets. Using Pulumi, I automated the deployment of an S3 bucket, set it up as a public website, and added a CloudFront CDN for speed and security—all coded in Python. This project replaced my old, tedious AWS console workflow with Infrastructure as Code (IaC).

Live Demo Link

Diary: https://d33ejg1jsmvn6g.cloudfront.net/index.html
Tutorial: https://d33ejg1jsmvn6g.cloudfront.net/tutorial.html

Project Repo

Check out my full code and a detailed README here:

https://github.com/vec21/pulumi-s3-challenge

My Journey

Hey there! I’m Veríssimo, a beginner in IaC, and this is my story of escaping the AWS console chaos. I used to spend 15 minutes per EC2 instance in the console—selecting instance types, networks, SSH keys—repeating it all for every test. It was slow and frustrating. For this challenge, I dove into Pulumi to deploy a static website, and it was a game-changer!

I started on Ubuntu (more on my Windows woes later). First, I installed Pulumi and AWS CLI:

curl -fsSL https://get.pulumi.com | sh
sudo apt install unzip curl -y
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" && unzip awscliv2.zip && sudo ./aws/install

I configured AWS credentials with aws configure, using an IAM user with full access to EC2, S3, CloudFront, and IAM.

Next, I tested Pulumi with the vm-aws-python template (pulumi new vm-aws-python). A quick pulumi up, a "yes," and my first EC2 instance was live in minutes! This hooked me, so I aimed bigger: a static website. Using pulumi new static-website-aws-python, I set out to host a diary and tutorial page. But my first pulumi up hit a snag:

TypeError: BucketV2._internal_init() got an unexpected keyword argument 'website'

The S3 V2 API had changed! After digging into Pulumi’s docs, I updated __main__.py:

bucket = aws.s3.BucketV2("bucket")
aws.s3.BucketWebsiteConfigurationV2("bucket-website", bucket=bucket.bucket, index_document={"suffix": "index.html"})

I added public permissions, and it worked!

To make the site fast and secure, I added CloudFront. My final __main__.py synced my ./www folder (HTML, CSS, JS, images) to S3 and set up a CDN. Running pulumi up --refresh gave me:

S3 URL: http://bucket-17bf36b.s3-website-us-west-2.amazonaws.com
CloudFront URL: https://d33ejg1jsmvn6g.cloudfront.net

Then came the Windows hiccup. My username "Veríssimo" (with an accent) broke Pulumi’s paths. Switching to "Verissimo" and rebooting locked me out—chaos! Thankfully, my Ubuntu dual-boot saved the day.

Lessons learned:

Avoid accents in Windows usernames—trust me!
S3 V2 needs separate website config—check the docs.
CloudFront is worth it for speed and HTTPS.

Using Pulumi

Pulumi turned a tedious task into a fun coding project. I used its Python SDK to define my infrastructure—first spinning up an EC2 instance with vm-aws-python, then building the static site with static-website-aws-python. In __main__.py, I configured an S3 bucket, website settings, and CloudFront distribution. It was beneficial because it saved me hours of console clicking, made my setup reproducible, and let me version-control it with Git. The Pulumi docs were key for fixing the S3 V2 issue. I didn’t use Pulumi Copilot, but splitting the bucket and website config was a critical manual tweak:

bucket = aws.s3.BucketV2("bucket")
aws.s3.BucketWebsiteConfigurationV2("bucket-website", bucket=bucket.bucket, index_document={"suffix": "index.html"})

Pulumi + Python = beginner-friendly power!