AWS Builder Center
Weekend Showcase Challenge: FieldIQ

Weekend Showcase Challenge: FieldIQ

FieldIQ uses AWS and Amazon Bedrock to turn cricket match analytics into AI-powered bowling strategies, threat zones, and field placements.

AI/ML Engineer | 4x AWS Certified | AI Researcher | ML | DL | Gen AI | AI Agents

Weekend Showcase Challenge: FieldIQ

#application

What if the next ball started with data?

In cricket, a bowler has only a few seconds to decide what to do next.
A batter has just hit a boundary. The required run rate is climbing. The captain needs to decide where to place the field, while the bowler needs to choose the next delivery.
There is usually enough information to help make that decision recent deliveries, scoring patterns, strike rate, match situation but it isn't always available in one place.
That was the problem I wanted to explore with FieldIQ.
FieldIQ is an AI-powered cricket strategy assistant that combines match context and batter analytics to generate a bowling plan, identify scoring threat zones, and recommend field positions.

🏏 From match data to a bowling strategy

The workflow is simple.
The user enters:
  • Batter and handedness
  • Bowler type
  • Match format
  • Current over
  • Current score
  • Target
  • Recent deliveries
FieldIQ then analyses the available delivery data and produces statistics such as runs, balls faced, strike rate, dot-ball percentage, boundary percentage, scoring zones, and recent momentum.
Those analytics are then provided to Amazon Bedrock, which generates the tactical part of the response.
The result brings together:
Analytics → Threat zones → Bowling plan → Field placement

FieldIQ combines batter analytics with an AI-generated bowling strategy and visual field placement.

The numbers are deterministic. The strategy is generative.

This was one of the main design decisions in the project.
I didn't want the language model calculating cricket statistics.
The Python analytics layer calculates the numbers first. For example, one of my test scenarios produces 11 runs from 6 balls, a 183.33 strike rate, 50% dot balls, and 33.33% boundary balls.
Those values come from application code.
Amazon Bedrock receives those calculated facts together with the match situation and is responsible for generating the strategy.
The expected response is structured around:
  • Risk level
  • Bowling plan
  • Recommended fielders
  • Threat zones
  • Reasoning
  • Alternative strategy
This separation makes the application easier to test and gives the AI a clearly defined role.

☁️ How I built FieldIQ on AWS

The application has a React/Vite frontend and a Python serverless backend.
The frontend is hosted with AWS Amplify. When the user submits a scenario, the React application sends a request to an Amazon API Gateway endpoint.
API Gateway invokes AWS Lambda, where the backend:
  1. Validates the request.
  1. Processes the match scenario.
  1. Calculates batter analytics.
  1. Builds the strategy context.
  1. Invokes Amazon Bedrock.
  1. Validates the generated response.
  1. Returns the structured recommendation to the frontend.
For the AI layer, I used Amazon Bedrock with Amazon Nova Micro.
I used AWS SAM to define and deploy the backend infrastructure, including the Lambda function, API configuration, environment variables, and IAM permissions.
The overall flow is:
User
↓
AWS Amplify
↓
Amazon API Gateway
↓
AWS Lambda
↓
Cricket Analytics
↓
Amazon Bedrock / Nova Micro
↓
Structured Recommendation
↓
FieldIQ UI

FieldIQ architecture: Amplify hosts the frontend, API Gateway exposes the API, Lambda handles analytics and orchestration, and Amazon Bedrock generates the tactical recommendation.

🧠 Making AI output reliable

Getting an AI model to return cricket advice is relatively straightforward.
Making that response safe for the rest of the application to consume is a different problem.
FieldIQ validates the Bedrock response before returning it.
For example, field positions must correspond to valid field-position IDs understood by the application. Bowling plans also have structural requirements, and malformed JSON is rejected.
I also added a deterministic local fallback for situations where Bedrock is disabled.
The backend is covered by unit tests for analytics, input validation, Bedrock response validation, malformed responses, invalid field positions, and fallback behaviour.
The final test run completed with:
16 tests passed.
For the Bedrock tests, I use a mocked client, so the test suite doesn't make real AWS model calls.

☁️ AWS services used

AWS service
How FieldIQ uses it
Why it is used
AWS Amplify
Hosts the React/Vite frontend and serves the live FieldIQ application
Provides a simple way to deploy and host the web interface
Amazon API Gateway
Exposes the POST /recommendation API endpoint
Connects the frontend to the serverless backend over HTTPS
AWS Lambda
Validates requests, runs cricket analytics, prepares the Bedrock context, and processes the response
Provides the backend without managing servers
Amazon Bedrock
Generates the bowling strategy, field recommendations, threat-zone reasoning, and alternative strategy
Adds the generative AI component to FieldIQ
Amazon Nova Micro
Model used through Amazon Bedrock for tactical recommendation generation
Provides the language-model reasoning used by the strategy layer
AWS SAM
Defines and deploys the Lambda/API infrastructure
Keeps the backend infrastructure configuration in source control

🚧 What was challenging?

The interesting part of this project wasn't simply connecting AWS services.
It was getting the complete application flow working.
I had to deal with frontend environment configuration, API Gateway CORS, Lambda configuration, Bedrock permissions, structured AI responses, and the difference between a local API and the deployed API.
Getting everything working locally is one thing.
Getting:
React → API Gateway → Lambda → Bedrock → React
working through a publicly deployed application is another.
That deployment process taught me a lot about how these individual services fit together.

🌱 What I learned

The biggest lesson I took from building FieldIQ was that generative AI doesn't need to control the entire application.
Traditional application code is better suited for deterministic calculations, validation, and business rules.
The model is useful where generation and reasoning are needed.
Keeping those responsibilities separate made FieldIQ easier to test and reason about.
I also learned that deployment is part of development. Environment variables, API configuration, IAM permissions, CORS, testing, and infrastructure definitions all matter just as much as the application code.
The summer challenges pushed me beyond:
"It works on my laptop."
and toward:
"It's deployed, testable, documented, and someone else can use it."

🔭 What's next?

I'm stopping the implementation here for this showcase, but there are several directions I'd like to explore later.
I'd like to add larger historical datasets, richer batter-vs-bowler analysis, more match-state awareness, multiple strategy options, and eventually delivery-by-delivery updates so recommendations can evolve as the innings progresses.
For now, the foundation is in place:
Match context → Analytics → AI strategy → Field placement.

🙌 Thanks to the builders who inspired me

I'd also like to thank Ben Fowler and Corey Strausman for their work and community engagement around the AWS Builder challenges.
These challenges gave me a reason to keep building, experiment with AWS services, and most importantly, actually ship the projects instead of leaving them as local prototypes.

🏏 Try FieldIQ

If you were building the next version of FieldIQ, what would you add first richer batter analytics, multiple bowling strategies, or real-time delivery-by-delivery recommendations?
I'd love to hear what other builders would do with it.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article