Building Resume Bravo-tizer: How AWS Serverless and Claude AI Transformed Our Resume Processing Workflow

TL;DR

I built a serverless resume processing system that converts any PDF resume into our standardized Bravo LT format using AWS services and Claude AI. The system went from concept to production in a few weeks, processing resumes automatically and saving our team hours of manual formatting work.

This post shares the technical architecture, implementation details, and lessons learned from building an AI-powered document processing pipeline.

The Problem That Kept Growing

At Bravo LT, our people are our products. We're a consultancy that places talented developers, business analysts, and scrum masters with clients who need top-tier technical talent. But here's the thing: every candidate comes to us with a different resume format, style, and structure.

Some resumes are beautifully designed but lack the technical depth our clients need to see. Others are packed with incredible experience but formatted in ways that don't align with our brand standards. A few are just... well, let's say they need significant help.

Before Resume Bravo-tizer, our process looked like this:

• Candidate submits resume

• HR team manually reviews and reformats

• Someone creates a new document following our template

• Back-and-forth emails to clarify experience details

• More formatting adjustments

• Finally, a standardized resume ready for client presentation

This process was taking 2-3 hours per resume, and we were processing dozens every week. The manual work was eating into time our HR team could spend on actual candidate engagement and relationship building.

Enter AWS Serverless and Claude AI

I knew there had to be a better way. The combination of AWS serverless services and the recent improvements in AI capabilities made this feel like the perfect problem to solve with automation.

The vision was simple: upload a PDF resume, get back a perfectly formatted Word document that matches our brand standards and highlights the most relevant experience for the target role.

But as anyone who's worked with document processing and AI knows, the devil is in the details.

The Architecture That Actually Works

After some experimentation, I settled on a three-component serverless architecture that's been rock-solid in production:

1. The Web Uploader (Django on AWS App Runner)

I built a secure Django web application that handles the initial user interaction. The uploader does several important things:

• Validates email addresses against our AWS SES verified senders list

• Lets users specify the target role (Developer, Business Analyst, Scrum Master)

• Provides drag-and-drop PDF upload with real-time progress

• Handles basic validation and error messaging

App Runner was perfect for this because I didn't want to deal with server management for what's essentially a simple form handler. The container-based deployment means I can iterate quickly without worrying about infrastructure.

2. The File Processor (AWS Lambda + Claude AI)

This is where the magic happens. When a resume hits our S3 upload bucket, it triggers a Lambda function that:

• Converts the PDF to base64 encoding

• Sends it to Claude Sonnet 4 via the Anthropic SDK

• Uses a carefully crafted prompt to extract structured data

• Outputs clean JSON with all the resume information

The Claude integration was surprisingly straightforward once I got the prompt dialed in (more on that below).

3. The JSON Processor (AWS Lambda + python-docx)

The final step takes the structured JSON data and creates a professionally formatted Word document using our Bravo LT template. This Lambda function:

• Reads the processed JSON from S3Generates a Word document with consistent formatting

• Includes role-specific experience highlighting

• Creates download links via S3 presigned URLs

AWS Step Functions: The Orchestration Layer

The real power comes from AWS Step Functions coordinating everything. The state machine handles:

• Sequential processing from PDF to JSON to Word

• Error handling at each step

• Email notifications for success and failure cases

• Retry logic for transient failures

Here's what I love about this approach: if any step fails, the user gets a specific error message, and I get debugging information. No more mystery failures or lost resumes.

The Art of Prompt Engineering

This is where things got really interesting. Claude is incredibly powerful, but getting consistent, high-quality output required serious prompt engineering work.

My initial prompt was basically "extract resume data into JSON format." The results were...inconsistent. Sometimes Claude would miss key experiences, other times it would hallucinate information, and the formatting was all over the place.

After several iterations (and feedback from our HR team), I landed on a prompt that's over 200 lines long and includes:

• Specific JSON schema definitions

• Role-specific experience mapping

• Quality standards for bullet point generation

• Examples of good vs. bad output

• Clear data validation rules

The breakthrough came when I realized I needed to give Claude context about what makes a good resume for each role. A developer's resume should highlight technical skills and project outcomes. A business analyst's resume should focus on process improvements and stakeholder management. A scrum master's resume should emphasize team facilitation and agile transformations.

Here's a snippet of how I structure the experience extraction:

Generate exactly 4-6 bullet points (never more, never less)

Each bullet point must be a complete, professionally written sentence

Lead with strong action verbs (Led, Developed, Implemented, Managed, Architected, etc.)

Include quantifiable results wherever possible (percentages, dollar amounts, team sizes, timeframes)

Prioritize experiences that directly relate to the target role

The difference between my first prompt and the final version is night and day. Our HR team went from "this needs a lot of cleanup" to "this is better than some resumes we get from candidates".

Why AWS Serverless Was the Right Choice

I could have built this as a traditional web application, but serverless made so much sense for this use case:

• Cost Efficiency: We only pay when processing resumes. No idle server costs.

• Automatic Scaling: Whether we process 5 resumes or 500, the system handles it without configuration.

• Reliability: AWS handles all the infrastructure concerns. I focus on business logic.

• Email Integration: SES integration is seamless for notifications and validation.

• Storage Management: S3 handles file storage with automatic lifecycle policies.

The entire system costs us less than $50/month to run, even with regular usage. Try doing that with traditional hosting.

The Claude Integration Experience

Working with Claude through the Anthropic SDK has been genuinely impressive. A few things that stood out:

• Context Understanding: Claude consistently understands the nuances of different resume formats and industries.

• Instruction Following: Once I refined the prompt, Claude followed the formatting rules precisely.

• Error Handling: Claude gracefully handles edge cases like non-resume PDFs or corrupted files.

• Consistency: The output quality is remarkably consistent across different resume types.

The API is fast (usually under 30 seconds for processing) and reliable. I've processed hundreds of resumes without a single Claude API failure.

Lessons Learned About Prompt Engineering

This project taught me that prompt engineering is as much art as science. Here are the key insights:

1. Be Incredibly Specific: Vague instructions lead to inconsistent results. If you want exactly 4-6 bullet points, say exactly that.

2. Provide Context: Claude performs better when it understands the business context and success criteria.

3. Include Examples: Show Claude what good output looks like for different scenarios.

4. Iterate Based on Real Data: The best prompts come from testing with actual resumes and real user feedback.

5. Structure Matters: A well-organized prompt with clear sections produces better results than a wall of text.

The browser-based Claude interface was invaluable during prompt development. I could test iterations quickly and get feedback before deploying to production.

The Results That Matter

Since launching Resume Bravo-tizer internally, we've processed over 200 resumes with impressive results:

• Time Savings: Resume processing went from 2-3 hours to 10 minutes.

• Consistency: Every resume follows our brand standards perfectly.

• Quality: HR team reports the AI-generated experience sections are often better than the originals.

• Scalability: We can process multiple resumes simultaneously without bottlenecks.

But the real win is qualitative. Our HR team can now focus on candidate relationships instead of document formatting. They spend time understanding career goals and matching skills to opportunities rather than fighting with Word templates.

What's Next

The system is working well, but there are some improvements I'm considering:

• Multi-language Support: Adding Spanish and French resume processing for our diverse candidate pool.

• Client Customization: Allowing different formatting templates for different client preferences.

• Skills Assessment: Using Claude to provide technical skill assessments based on experience descriptions.

• Integration: Connecting with our existing HR systems for seamless candidate management.

The Technical Stack That Delivered

For anyone interested in the specific technologies:

Backend Services:

• AWS Lambda (Python) for processing functions

• AWS Step Functions for workflow orchestration

• AWS S3 for file storage

• AWS SES for email delivery

• AWS App Runner for web hosting

AI & Processing:

• Anthropic Claude Sonnet 4 for resume analysis

• python-docx for Word document generation

• boto3 for AWS service integration

  
  

Web Application:

• Django for the upload interface

• Gunicorn for production serving

• WhiteNoise for static file handling

Infrastructure:

• CloudFormation for resource provisioning

• Docker for Lambda containerization

• ECR for container image management

The entire infrastructure is defined as code, making deployments and updates straightforward.

Why This Matters for Consultancies

If you're in the consulting or staffing business, this type of automation can be transformative. The ability to quickly standardize candidate presentations while maintaining quality gives you a significant competitive advantage.

Your team can focus on what humans do best: relationship building, strategic thinking, and nuanced decision making, while AI handles the repetitive document processing work.

Key Takeaways for Building Similar Systems

For those considering similar document processing automation:

1. Start with the Business Problem: Define your success metrics clearly before diving into technical solutions.

2. Invest in Prompt Engineering: The quality of your AI output depends heavily on how well you guide it.

3. Embrace Serverless for Variable Workloads: Document processing often comes in bursts - serverless handles this perfectly.

4. Build in Observability: Good error handling and logging make debugging much easier.

5. Iterate Based on User Feedback: Your first version won't be perfect, and that's okay.

Closing Thoughts

Building Resume Bravo-tizer reinforced my belief that the best AI applications solve real, specific business problems. This isn't about replacing human judgment , it's about eliminating tedious manual work so people can focus on higher-value activities.

The combination of AWS serverless services and Claude AI made it possible to build a production-ready system in weeks, not months. The prompt engineering process was challenging but ultimately rewarding, and the results speak for themselves.

If you're dealing with similar document processing challenges, I'd encourage you to explore what's possible with modern AI and cloud services. The technology has reached a point where solutions that seemed impossible a few years ago are now straightforward to implement.

The success of this project has opened doors for other automation initiatives within our organization. When you can demonstrate concrete ROI, both in time saved and quality improved, it becomes easier to justify investment in similar solutions.

As always, if you found this helpful, feel free to connect with me on LinkedIn or check out my other projects on GitHub. I'm always interested in discussing serverless architecture patterns and AI implementation strategies with others tackling similar challenges.

P.S. - The system successfully processed my own resume as a test case. Claude's assessment of my experience was surprisingly accurate and well-written. Sometimes the AI knows us better than we know ourselves.

Written by Justin Wheeler, AWS Community Builder and Senior Software Developer at Bravo LT.