CollectIQ

We're Bringing Wall Street-Level Intelligence to Pokémon TCG Cards

Comment

Inspiration

We're a team of Pokémon fans. Not just casual fans. The kind who've traveled to Japan to visit Pokémon Centers and themed cafes. The kind who still catch Pokémon on morning walks with Pokémon Go. The kind who've played through every main series game. And the kind who spend hours watching TCG content creators on YouTube and Twitch, living vicariously through their reactions when they pull a rare Charizard or a vintage Blastoise.

One of us collected cards as a kid. Another has a boyfriend who's deep into the hobby. All of us, in one form or another, have a connection to Pokémon cards. But none of us actively collect today. Why? Because the market has become intimidating.

A first edition Charizard can sell for over $400,000 (source: ebay GradedExchange, 2025). Even mid tier cards go for hundreds. And with that kind of money at stake, the market is flooded with counterfeits. We've watched streamers get scammed. We've seen Reddit threads full of collectors who paid thousands for fake cards. We've heard stories from friends who got burned.

The question kept nagging us: how do you know if a card is real? How do you know if you're paying a fair price or getting ripped off? The answer today is you don't. Unless you're an expert with years of experience, or you pay $50 to $500 to send your card to PSA or BGS for professional grading.

That's when it clicked. This is exactly the kind of problem AI should solve. If we can use AI to diagnose diseases and drive cars, why can't we use it to authenticate a Pokémon card? Why can't we give every collector the same tools that Wall Street traders have? Real time data. Confidence scoring. Explainable analysis.

CollectIQ was born from that realization. We wanted to build something that would let us (and millions of other fans) participate in the hobby we love without the fear of getting scammed. Something that democratizes expertise. Something that makes the market fair.

What it does

CollectIQ turns your smartphone into a professional card authentication lab.

Here's the magic: you snap a photo of your Pokémon card, and within about a minute, our AI tells you two critical things:

  1. Is it real? We analyze holographic patterns at the pixel level, check font kerning and border symmetry, compute perceptual hashes, and compare against known authentic cards. You get an authenticity score (0-100) with clear signals about what looks right or suspicious.

  2. What's it worth? We aggregate pricing data from multiple sources (currently eBay and Pokémon TCG API, with plans to add TCGPlayer and PriceCharting), remove outliers, and compute a fair value range with confidence intervals. No more guessing based on one random eBay listing.

But here's what makes CollectIQ different: explainable AI. We don't just give you a number. Claude Sonnet 4.0 explains the reasoning: "This card shows strong holographic variance consistent with authentic Base Set holos. Recent eBay sales range from $450 to $550 for Near Mint condition. Market trend is stable. Fair value: $500 ± $50."

You also get a secure vault to track your entire collection's value over time, with one-click revaluation to see how the market is moving.

How we built it

We went all-in on AWS serverless architecture because we wanted to prove you can build production-grade AI systems without managing a single server.

The Architecture:

We built a multi-agent AI system with four specialized agents working together, orchestrated by AWS Step Functions:

  1. Rekognition Extract Agent: Uses AWS Rekognition to pull text, labels, and visual features from the image
  2. OCR Reasoning Agent: Amazon Bedrock (Claude Sonnet 4.0) interprets the raw OCR text, corrects errors, and extracts structured metadata
  3. Pricing Agent: Calls pricing APIs (eBay and Pokémon TCG API), aggregates data, and uses Amazon Bedrock (Claude Sonnet 4.0) to generate a valuation summary
  4. Authenticity Agent: Analyzes visual features and uses Amazon Bedrock (Claude Sonnet 4.0) to detect counterfeits

These agents are coordinated by Lambda functions that aggregate results, persist to DynamoDB, and handle errors gracefully.

The Stack:

  • Frontend: Next.js 14 with App Router, Tailwind CSS, deployed on AWS Amplify
  • Backend: TypeScript Lambda functions
  • AI: Amazon Bedrock (Claude Sonnet 4.0) + Amazon Rekognition
  • Orchestration: AWS Step Functions for the multi-agent workflow
  • Database: DynamoDB with single-table design
  • Storage: S3 with presigned URLs for secure uploads
  • Auth: Cognito with OAuth 2.0 + PKCE
  • Infrastructure: Everything defined in Terraform
  • Monitoring: CloudWatch + X-Ray for complete observability

We also built an event-driven system using EventBridge. When you upload a card, it automatically triggers the AI analysis. No waiting, no clicking "Analyze" buttons. It just works.

The Development Process:

We started with the core problem: how do you teach an AI to understand Pokémon cards? We researched authentication techniques used by professional graders, studied pricing methodologies from financial markets, and experimented with different AI prompting strategies.

The breakthrough came when we realized we needed specialized agents, not one monolithic AI. Each agent became an expert in its domain: one for reading text, one for pricing, one for authenticity. Then we orchestrated them with Step Functions to work in parallel.

We built everything with production in mind. Complete infrastructure as code with Terraform. Comprehensive monitoring and observability. Proper error handling and graceful degradation.

Challenges we ran into

Challenge 1: OCR is Terrible at Reading Pokémon Cards

Rekognition would read "Charizard" as "Char1zard" or completely miss the set symbol. We couldn't just pass raw OCR to pricing APIs. We'd get zero results.

Solution: We built an OCR Reasoning Agent using Claude Sonnet 4.0. It takes the messy OCR output, uses context clues (copyright text, card layout, visual features), and intelligently corrects errors. It's like having a human who knows Pokémon cards look at the OCR and say "Oh, that's obviously supposed to be 'Charizard' not 'Char1zard'."

Challenge 2: Pricing Data Sources Are a Minefield

Getting access to pricing APIs turned out to be harder than we expected. TCGPlayer stopped granting new API access entirely. PriceCharting costs $50 per month. eBay requires developer approval, which meant waiting (thankfully only one business day). The Pokémon TCG API was the easiest. Free developer program, straightforward integration.

Solution: We started with what we could access: eBay and Pokémon TCG API. We built a flexible pricing orchestrator with circuit breakers, rate limiting, and exponential backoff so we could add more sources later. We also added API level caching in DynamoDB (30 minute TTL) to reduce costs and avoid hammering the same endpoints. The architecture is designed to gracefully degrade. If one API fails, we continue with the others.

Challenge 3: How Do You Explain AI Decisions?

Early versions just gave a number: "This card is worth $500." As we tested internally, we kept asking ourselves "Why? How do we know?" We realized that if we didn't trust the output without explanation, neither would real users. Trust requires transparency.

Solution: We use Claude Sonnet 4.0 to generate human readable explanations. It doesn't just compute. It explains. "Based on 15 recent eBay sales ranging from $450 to $550, and Pokémon TCG API market data showing stable trends over the past 30 days, fair value is $500 with high confidence."

Challenge 4: Lambda Cold Starts and Performance

Lambda cold starts can kill user experience. We knew we needed to optimize, even if we didn't have time to measure every improvement during the hackathon.

Solution: We optimized our bundle sizes with esbuild and implemented connection pooling for DynamoDB. We also added real time progress indicators so users see the agents working. It feels fast even when it's processing.

Challenge 5: Keeping Costs Under Control

With Bedrock, Rekognition, and multiple API calls per card, costs could spiral quickly. We needed to stay within hackathon budget constraints while proving the model could scale.

Solution: We obsessed over cost optimization. Right sized Lambda memory allocations (256 to 512 MB). Optimized Bedrock prompts to reduce token consumption. Implemented API level caching in DynamoDB to avoid redundant calls. Used DynamoDB on demand billing to pay only for what we use. Reduced log verbosity in production mode. The result? Estimated $20 to $50 per month at hackathon scale, staying well within AWS free tier limits. Our projections show that even at 50,000 card analyses per month, costs would only reach $400 to $700. That's sustainable and proves the business model works.

Challenge 6: AWS Amplify Wouldn't Deploy Our Monorepo

We built CollectIQ as a pnpm monorepo for clean code organization. Backend, frontend, shared packages, all in one repo. But when we tried to deploy the frontend to AWS Amplify, builds kept failing. We couldn't figure out if it was our configuration or if Amplify just couldn't handle pnpm workspaces gracefully.

Solution: We got creative with Git subtrees. We extracted apps/web from the main monorepo (https://github.com/jayvicsanantonio/collect-iq) into a separate repository (https://github.com/jayvicsanantonio/collect-iq-ui). Switched from pnpm to plain npm in the subtree repo. Deployed the standalone repo to Amplify instead. It worked perfectly. Now we maintain both repos: the monorepo for development, and the subtree for deployment. Git subtree commands keep them in sync. Not ideal, but it got us deployed.

Accomplishments that we're proud of

1. We Built a Production-Ready System in a Hackathon

This isn't a prototype. It's production-ready. We have monitoring, logging, error handling, disaster recovery, cost optimization, comprehensive documentation, and infrastructure as code. You could deploy this to production tomorrow.

2. The Multi-Agent Architecture Actually Works

We proved that you can build sophisticated multi-agent AI systems on AWS serverless infrastructure. Four specialized AI agents, orchestrated by Step Functions, processing cards in parallel, with explainable AI reasoning. It's beautiful.

3. The AI Explanations Are Genuinely Helpful

We didn't just slap GPT on top of some APIs. We carefully crafted prompts, tuned confidence thresholds, and iterated on the reasoning format. The result is AI that explains itself in a way that builds trust with collectors.

4. We Built Something We Actually Want to Use

As Pokémon fans who watch TCG content creators and follow the market, we built CollectIQ to solve problems we personally experience. The fear of counterfeits. The uncertainty about fair prices. The complexity of authentication. We're not just building for some abstract user. We're building for ourselves and the community we're part of. That authenticity shows in every feature.

5. We Discovered Kiro's Spec Driven Development

We embraced Kiro's spec driven development workflow and it was a game changer. Breaking down features into requirements, design, and implementation tasks kept us organized and moving fast. But what really impressed us was how deeply integrated and knowledgeable Kiro is with AWS. It understood our serverless architecture, suggested best practices for Step Functions and Bedrock, and helped us navigate the complexity of multi agent systems. Building with Kiro felt like having an AWS expert on the team.

6. Cost Efficiency at Scale

We proved that AI powered services can be affordable. Our detailed cost analysis shows $20 to $50 per month at hackathon scale, staying within AWS free tier. Even at 50,000 card analyses per month, projections show only $400 to $700 in infrastructure costs. That's roughly $0.01 per card analysis. Serverless architecture means we pay only for what we use, with no idle costs. The economics work.

What we learned

Technical Learnings:

  • Multi-agent systems are powerful: Breaking complex problems into specialized agents makes everything cleaner and more maintainable
  • Step Functions are underrated: Visual workflows, built-in retry logic, and execution history make debugging so much easier
  • Bedrock is production ready: Claude Sonnet 4.0 is fast, cost effective, and produces genuinely useful outputs
  • Serverless scales beautifully: We can handle 10 requests or 10,000 requests with the same architecture
  • Observability is critical: CloudWatch + X-Ray saved us countless hours of debugging

Product Learnings:

  • Explainability builds trust: Users don't just want answers. They want to understand why.
  • Speed matters: Under a minute feels instant with good UX and real time progress indicators.
  • Mobile first is essential: Collectors want to authenticate cards at card shops, conventions, and garage sales.
  • Confidence scores are crucial: Telling someone "I'm 95% confident" vs "I'm 60% confident" changes everything.

Market Learnings:

  • The problem is real: Counterfeits are a massive issue in the TCG market
  • Collectors want data: They're hungry for market intelligence and trend analysis
  • There's a platform play: Dealers and shops would pay for bulk API access
  • The market is huge: $14B for Pokémon, $400B+ for all collectibles

Personal Learnings:

  • Documentation matters: Good docs make everything easier. Debugging, onboarding, explaining to judges.
  • Start with the problem: We could have built cool tech that solves nothing. Instead, we started with collector pain points.
  • Production ready takes time: The last 20% (monitoring, error handling, cost optimization) takes 80% of the effort, but it's what separates toys from tools.

What's next for CollectIQ

The Vision:

CollectIQ becomes the Bloomberg Terminal for collectibles. The go to platform for real time market data, authentication, and intelligence. Every collector, dealer, and marketplace uses CollectIQ to make informed decisions.

We're not just building a card scanner. We're building the infrastructure for trust and transparency in the entire $400 billion collectibles market.

Technical Roadmap:

  1. AgentCore Gateway: Expose existing Lambda functions as AgentCore Gateway tools using Model Context Protocol (MCP). Centralize tool management for pricing APIs (eBay, Pokémon TCG), Rekognition calls, and DynamoDB operations. Enable standardized agent to agent communication. Reduces code duplication and provides foundation for multi agent extensibility.

  2. AgentCore Memory Integration: Deploy AgentCore Memory with custom strategies for user preferences and card history. Migrate Pricing Agent to AgentCore Runtime with memory enabled personalization. Implement automatic preference extraction using Claude Sonnet 4.0. Enables personalized pricing recommendations and conversation continuity.

  3. Browser Tool for Market Research: Deploy AgentCore Browser Tool with session recording. Create Research Agent using Strands framework for real time web research. Enable agents to supplement API data with auction monitoring and community sentiment analysis. Provides access to data beyond APIs and real time market intelligence.

  4. Orchestrator Agent: Implement supervisor agent using LangGraph for dynamic multi agent coordination. Replace Step Functions orchestration with AI driven routing decisions. Enable agent to agent invocation through Gateway for flexible workflows. Improves debugging and makes adding new agents easier.

  5. Advanced Vision Models: Train custom computer vision models for specific card sets and holographic patterns. Fine tune authenticity detection for regional variants and special editions. Implement advanced counterfeit detection using deep learning. Increases accuracy and reduces false positives.

Why We'll Succeed:

We're not just passionate about Pokémon cards. We're passionate about solving real problems with great technology. We've proven we can build production ready systems. We've shown we understand the market. And we've demonstrated that AWS's serverless and AI services can power the next generation of intelligent applications.

This is just the beginning.

Built With

  • amazon-bedrock
  • amazon-rekognition
  • amazon-web-services
  • aws-amplify
  • aws-cloudwatch
  • aws-event-bridge
  • aws-lambda
  • aws-step-functions
  • aws-xray
  • cognito
  • dynamo-db
  • nextjs
  • oauth
  • tailwindcss
  • terraform
  • typescript
Share this project:

Updates