Weekend Annoying Task Challenge: Builder Persona — An AI Badge That Introduces You Before You Speak
How I spent a weekend turning meetup introductions into a generated avatar and badge — and the three failures that shaped it: a test I built to break my own app, a dog that came back as a shield, and a race condition between four Lambda functions.
I built a serverless app that turns a short form into an avatar and a badge, so people at an event can see what you build before they talk to you. No real name, no company, no contact details. Amazon Bedrock Nova Canvas plus four Lambda functions. At my current prototype traffic, image generation is the only meaningful cost.
#productivity #amazon-bedrock #aws-lambda #serverless #aws-community
Two of my regulars found out they were solving the same container networking problem in the parking lot, on the way to the station. They had both attended every event that year.
I help organize a Chinese-speaking AWS User Group in Tokyo. Every meetup starts the same way: a round of introductions where everyone says a job title and a company, and nobody remembers past the third person. After that, the useful conversations happen by chance.
The annoying task it eliminates: reintroducing yourself at every event and hoping the useful part comes up.
Vision and What the App Does
Builder Persona takes a short form — a handle, MBTI type, technical interests, community role, favorite AWS service, city, and visual style — and generates two things:
- An avatar sized for GitHub, LinkedIn, Discord, Slack, and X
- A Builder Badge with a compact code like
BC-INTJ-ARC-LM-TYO
The app maps MBTI onto eight presentation-oriented Builder Types that drive color, composition, and iconography. It's a display rule, not a personality assessment — the full mapping is in the repo README.
No real name, company, or contact details are required. A nickname is enough. For something you pin on and hand to strangers, that constraint is the point.
The core flow works end to end: submit the form, wait for the asynchronous job, and get back an avatar and a Builder Badge. The pipeline also produces an experimental Personality Card, but the two outputs I consider part of the MVP are the avatar and the badge.
What I'm still iterating on is visual quality, not functionality — I think the eight Builder Types should look more distinct from each other than they currently do, and that's a prompt engineering problem rather than a broken feature.
How I Built It
Friday night: I tried to let a model decide who you are. It lasted an hour.
My first design handed the whole profile to a language model and asked it to classify the user. Then I tried to write a test for it and realized I couldn't. Two identical inputs produced different Builder Types. For something people wear on their chest at an event, that isn't a tradeoff — it's a defect. I moved classification into plain TypeScript and never looked back.
Saturday morning: I built the test that broke my own app.
I generated a persona for myself. It looked great, and I nearly moved on. But one good output proves nothing — the whole premise is that different Builder Types produce distinguishable results. So I generated one profile per type, held every other field constant, covered the labels, and tried to sort them.
I couldn't. All eight were the same generic tech-person illustration with a slightly different background tint.
Saturday evening: I seriously considered deleting the Builder Type feature.
I had spent the afternoon adding more detail to the prompt — more traits, more adjectives, more context — and the images were still nearly identical. With a deadline the next day, cutting the concept and shipping a plain avatar generator started to look like the sensible move. At that point I wasn't sure I'd have something worth publishing on Sunday at all.
What saved it wasn't more prompt text. It was ordering the text I already had: reference subject first, then style, then Builder Type expressed as mood and color, then role and city as secondary details. Abstract traits like "analytical" do nothing to an image model. "Cool blue night lighting, elevated vantage point" does. I reran the eight-profile test and could finally sort them blind.
That reordering took ten minutes. The three hours before it were spent solving the wrong problem.
A user's dog came back as a shield.
Someone uploaded a photo of their dog with Security Guardian selected. The model returned a shield and a generic mascot — no dog. The style portion of my prompt was quietly replacing the actual subject, which for a badge meant to represent you is the worst possible failure. The fix: invert the priority whenever a reference image exists, preserving the subject first and demoting every builder attribute to lighting, a small accessory, and background. Normalizing uploads in the browser before sending them removed another whole class of format failures I'd otherwise be debugging in Lambda.
I let the image model render the badge text. That lasted about five minutes.
It produced genuinely beautiful badges with unreadable labels — and a garbled badge code looks authoritative while being wrong, which is worse than having none. So I generate the artwork first and composite the text and QR code separately as SVG.
A job said COMPLETED while the card was still missing.
Image generation is too slow and too variable for a synchronous request, so the API creates a job and returns immediately: one Lambda generates the avatar, then invokes a second for the badge and card. My first version had a single
completed flag that either worker could set — so users got a success screen with a broken image. Splitting it into per-stage status fields fixed it. Obvious in hindsight, not obvious at eleven at night.I stopped hiding failures behind placeholder images.
When Nova Canvas returns nothing, the app falls back to a simple generated placeholder. My first instinct was to show it silently — it looks better in a demo. I changed it to record where the image actually came from and show a warning instead. Debugging got dramatically easier, because I could query for failures instead of guessing at them.
Two things I'm glad I didn't build. The model-based classifier from Friday night — not building it is why every MBTI mapping is a unit test today. And the async pipeline I first sketched with Step Functions, a state machine, and an EventBridge completion channel. For a two-stage job that finishes in seconds, that's architecture as decoration. Two Lambdas invoking each other was faster to build and far easier to debug.
AWS Services Used / Architecture Overview
How it's triggered: entirely user-initiated. The browser POSTs the form, each stage asynchronously invokes the next and updates its own status, and the frontend polls until the assets appear. No scheduler, no queue.
Browser -> API Gateway -> Lambda -> Amazon Bedrock (Nova Canvas) -> DynamoDB -> S3 -> CloudFrontFour Lambda functions sit behind that single arrow: one creates the job, one reports status, one generates the avatar, and one renders the badge and composites the card. DynamoDB holds per-stage job status so the two generators can't mark each other complete.
Service | Role |
|---|---|
AWS Lambda | Four functions: API create, API status, avatar, badge/card |
Amazon Bedrock | Nova Canvas generates the avatar and card background |
Amazon API Gateway | Create and status endpoints |
Amazon DynamoDB | Profile and per-stage job status |
Amazon S3 | Generated assets, public access blocked |
Amazon CloudFront | Asset delivery via Origin Access Control |
AWS Amplify Hosting | React frontend |
AWS CDK | All infrastructure in TypeScript |
Source photos are optional. The browser normalizes them before submission, and the application does not write them to DynamoDB or the generated-assets bucket — only the resulting avatar, badge, and job metadata are retained. Bedrock image generation is the only meaningful cost; the rest of the infrastructure sits within the applicable Free Tier allowances at prototype traffic.
What I Learned
- Prompt priority beats prompt length. I only found this after generating the same builder eight times and failing to tell the results apart. An afternoon of adding detail did nothing; ten minutes of reordering fixed it. Image models act on lighting, composition, palette, and vantage point — not on abstract traits.
- A reference image needs an explicit subject-first instruction, or the style portion of your prompt will silently replace the subject. I'd never have caught this without someone uploading a dog.
- Image models can't render exact text. Five minutes of beautiful badges with unreadable labels was enough. Generate the artwork without text, composite labels as SVG.
- Two async workers need per-stage status fields. A single shared
completedflag shipped a success screen with a missing image before I caught it.
- Deterministic classification is what makes an AI app testable. Because TypeScript decides the Builder Type, I can assert in CI that INTJ still maps to Cloud Architect. The moment a model decides that, the app becomes unverifiable.
Link to App & Repo
Both links point to the working prototype I finished during the challenge weekend. Generating an avatar and a Builder Badge from a short profile is complete and fully functional. I'm continuing to refine the prompts and visual style in the same repository, so the links stay current.
Deploy your own:
git clone https://github.com/weny2000/aws-builder-badgecd aws-builder-badgenpm install
cd backendnpx cdk bootstrapnpx cdk deploy --require-approval never
Things I Intentionally Didn't Build This Weekend
- Visual distinctiveness across all eight Builder Types. The generation works, but some types read more clearly than others. This is prompt engineering, not a missing feature, and it's the main thing I'm still improving.
- A public profile behind the QR code — right now it just holds the Builder Code, which means the app stops one step short of the introduction it exists for
- Authentication and saved profile history
- Expiration for generated assets
- Throttling on the create endpoint, which it needs before I share it widely
The badge also reflects what someone selected about themselves, which is the same self-reporting weakness as a name tag. I don't think that's fixable, and I'm not sure it needs to be — "You're a Data Explorer? I'd have said DevOps" is a conversation, and a job title has never started one.
Next weekend: the profile behind the QR code, so I can scan a badge at the next event and find out someone works on containers before the conversation starts — instead of in the parking lot.
I'll bring it to that meetup and see whether people actually wear the badges. If they don't, I'll know the app still isn't solving the right problem.
The version linked above is the exact one I finished during the challenge weekend. Come back in a month and the prompts will probably be better — but I wanted to submit the real project I built, not wait until it felt perfect.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article