AWS Builder Center

Building Snaplit AI: Adding AI-Powered Content Intelligence with AWS

I extended Snaplit, an Instagram-inspired social platform, with an AWS-powered AI layer for image understanding, caption generation, and automatic content tagging. This article covers the problem, architecture, AWS services, implementation approach, and lessons learned while building the feature during the Bharat Builds Tour hackathon.

Building Snaplit AI: Adding AI-Powered Content Intelligence with AWS

Introduction

Social media makes sharing visual content extremely easy. However, creating a good caption, describing an image, choosing relevant tags, and making visual content accessible can still require manual effort.
I wanted to explore whether these tasks could be integrated directly into the social-media experience instead of forcing users to switch between multiple tools.
That led to Snaplit AI.
Snaplit is an Instagram-inspired social media platform that I built using React, TypeScript, Tailwind CSS, Vite, and Appwrite. It includes features such as authentication, posts, stories, reels, profiles, likes, comments, saves, messaging, notifications, and settings.
For the Bharat Builds Tour — First Commit hackathon, I extended Snaplit with an AWS-powered AI content intelligence layer.
The goal was simple:
Make creating and understanding visual social-media content easier with AI.



The Problem

A typical social-media post may require several manual steps after a user selects an image:
  1. Decide what to write as a caption.
  1. Describe what is present in the image.
  1. Choose relevant tags.
  1. Make the content understandable to users who may not be able to interpret the image visually.
None of these problems individually requires a complicated solution, but together they create unnecessary friction in the content creation workflow.
I wanted Snaplit to assist with these tasks while still keeping the user in control.
The AI should be an assistant, not an automatic replacement for the creator.



What is Snaplit AI?

Snaplit AI adds intelligent content assistance directly to the existing social-media workflow.
The core idea is:
User uploads visual content
↓
Snaplit AI
↓
AI understands it
↓
┌────────┼─────────┐
↓ ↓ ↓
Caption Tags Description
└────────┼─────────┘
↓
User reviews
↓
Publishes

The initial AI functionality focuses on three areas:

1. Image Understanding

The AI analyzes uploaded visual content and generates a meaningful description.
For example:
Input:
A photograph showing a person standing
near snow-covered mountains.

Generated description:
"A person standing outdoors in a
snow-covered mountainous landscape."

This can also contribute to making visual content more accessible.

2. Caption Generation

Instead of starting from a blank text box, users can receive an AI-generated caption suggestion.
For example:
Image:
Mountain hiking photograph

Suggested caption:
"Chasing new heights and finding quiet
between the mountains."

The user can edit the suggestion before publishing.

3. Automatic Tags

Snaplit AI can identify concepts related to the uploaded content and suggest relevant tags.
For example:
#mountains
#travel
#nature
#hiking
#adventure

These tags can help organize and discover content.



Why AWS?

The existing Snaplit application already uses Appwrite for its core social functionality.
Rather than rewriting a working application during a hackathon, I decided to introduce AWS specifically where it provides the most value: the new AI processing workflow.
This created a hybrid architecture:
Snaplit
|
React + TypeScript
|
┌───────┴────────┐
| |
Appwrite AWS
| |
Social backend AI pipeline

Appwrite continues to handle the existing social application, while AWS provides the infrastructure for the new AI functionality.
This approach also allowed me to learn how cloud services can be introduced incrementally into an existing application.



Architecture

The target architecture for Snaplit AI is:
┌─────────────────┐
│ User │
└────────┬────────┘
│
▼
┌─────────────────┐
│ Snaplit React │
│ Frontend │
└───────┬─────────┘
│
┌──────────────┴──────────────┐
│ │
▼ ▼
┌───────────────┐ ┌───────────────┐
│ Appwrite │ │ Amazon S3 │
│ Social Backend│ │ Media Storage │
└───────────────┘ └───────┬───────┘
│
▼
┌───────────────┐
│ AWS Lambda │
│ AI Processing │
└───────┬───────┘
│
▼
┌───────────────┐
│ Amazon │
│ Bedrock │
└───────┬───────┘
│
▼
Description / Tags /
Caption
│
▼
┌───────────────┐
│ Snaplit │
│ AI Result │
└───────────────┘




AWS Services Used

Amazon S3

S3 provides object storage for media involved in the AI processing workflow.
The AI pipeline needs a reliable way to access uploaded media, and S3 provides a natural integration point for AWS-based processing.
The role of S3 in the architecture includes:
  • Media storage
  • Reliable object access
  • Integration with the serverless workflow
  • Scalable storage for future growth



AWS Lambda

Lambda is used as the serverless processing layer.
Instead of maintaining a dedicated backend server just for AI requests, Lambda allows the application to execute the required processing when an AI request is made.
The Lambda workflow is responsible for tasks such as:
  • Receiving an AI processing request
  • Accessing the relevant media
  • Preparing the AI request
  • Calling the AI service
  • Processing the response
  • Returning structured information to Snaplit
This was particularly useful for a hackathon because it reduced infrastructure management.



Amazon Bedrock

Amazon Bedrock provides the foundation for the AI functionality.
Instead of training and hosting a machine-learning model from scratch, the application can use managed foundation-model capabilities through AWS.
For Snaplit AI, the model is used for tasks such as:
  • Visual content understanding
  • Image descriptions
  • Caption suggestions
  • Relevant content tags
The important part for me was not simply calling an AI model, but integrating AI into an actual product workflow.



Amazon CloudWatch

CloudWatch provides observability for the serverless processing layer.
When working with Lambda and external AI services, failures can happen at multiple points.
CloudWatch helps inspect:
  • Lambda execution logs
  • Runtime errors
  • Processing failures
  • Request behavior
  • Debugging information
This becomes increasingly important as the AI workflow becomes more complex.



End-to-End AI Flow

The complete workflow can be thought of as the following sequence:
1. User creates a post
↓
2. User uploads an image
↓
3. Media is made available to the AWS workflow
↓
4. Lambda receives the processing request
↓
5. Lambda prepares the AI request
↓
6. Amazon Bedrock analyzes the content
↓
7. AI generates structured results
↓
8. Lambda processes the response
↓
9. Snaplit receives the results
↓
10. User reviews the suggestions
↓
11. User publishes the post

The user remains in control throughout the process.



Existing Snaplit Architecture

Before adding the AI layer, Snaplit was already a complete social-media-style application.
The frontend is built using:
  • React
  • TypeScript
  • Vite
  • Tailwind CSS
  • React Router
  • React Query
  • Framer Motion
  • Radix UI
Appwrite provides the existing backend functionality:
  • Authentication
  • Database
  • Storage
  • User data
  • Social relationships
  • Posts
  • Stories
  • Reels
  • Messages
  • Notifications
The AI functionality is therefore an extension rather than a replacement of the existing application.



Why I Chose a Hybrid Architecture

One of the most important architectural decisions was not migrating the entire application to AWS.
A full migration would have required replacing working authentication, database, storage, and application logic.
That would introduce significant risk during a short hackathon.
Instead, I asked:
Where can AWS provide the most meaningful improvement to the existing product?
The answer was the AI workflow.
This resulted in a more focused architecture:
Existing product
+
AWS-powered capability
=
Snaplit AI

This approach also demonstrates an important real-world engineering concept: cloud adoption does not always mean rewriting an entire application.



Challenges

Building the feature within a hackathon timeframe came with several challenges.

1. Integrating AWS with an existing application

Snaplit was already built around Appwrite, so the AWS services needed to integrate without disrupting the existing social functionality.
This required separating the AI workflow from the existing application backend.

2. Serverless configuration

Lambda introduced a different development model compared with a traditional always-running backend.
Configuration, environment variables, permissions, and debugging all required additional attention.

3. AI integration

Working with AI models is different from calling a conventional API.
The input needs to be structured carefully, and the output needs to be processed before it can be safely presented to the application.

4. Time constraints

The hackathon timeframe forced me to prioritize.
Instead of trying to build dozens of AI features, I focused on a small number of features that could demonstrate the value of AI clearly.



What I Learned

This project taught me several practical lessons.

Cloud architecture

I learned how different AWS services can be combined into a complete application workflow instead of treating each service independently.

Serverless development

Lambda helped me understand the benefits and tradeoffs of event/request-driven backend processing.

Managed AI

Amazon Bedrock showed me how applications can integrate foundation-model capabilities without managing model infrastructure themselves.

Hybrid systems

I learned that an existing application does not necessarily need to migrate completely to a new cloud provider to benefit from cloud services.

AI product design

Perhaps the biggest lesson was that adding AI is not about adding an AI button.
The AI capability needs to solve an actual user problem.
For Snaplit, that meant focusing on:
  • Reducing caption-writing effort
  • Understanding visual content
  • Generating useful tags
  • Improving accessibility



What I Would Build Next

Snaplit AI is designed to be extended.
Future possibilities include:

Semantic Search

Allow users to search for content using natural language.
For example:
"Show me posts about mountain trips."
instead of requiring exact keyword matches.

AI Recommendations

Use content understanding and user interactions to improve personalized recommendations.

Automated Accessibility

Automatically generate high-quality alt text for uploaded images.

Content Moderation

Use AI to identify potentially harmful or inappropriate content before publication.

Multilingual Captions

Generate captions in multiple languages for creators targeting different audiences.

AI Creator Assistant

A conversational assistant could help creators:
  • Plan posts
  • Generate captions
  • Suggest hashtags
  • Improve descriptions
  • Analyze engagement patterns



Security Considerations

AWS credentials should never be exposed in frontend code.
The application should follow the principle of least privilege when configuring IAM permissions.
Sensitive configuration should remain server-side, while the frontend should communicate with controlled backend endpoints.
For production deployments, additional security measures would include:
  • Strict IAM policies
  • S3 access controls
  • Input validation
  • File-type validation
  • Request authentication
  • Rate limiting
  • AI output validation
  • Monitoring and alerting



Conclusion

Snaplit started as an Instagram-inspired social media platform.
For the Bharat Builds Tour — First Commit hackathon, I extended it into Snaplit AI, using AWS to introduce intelligent content capabilities directly into the social-media workflow.
The project combines:
React
+
TypeScript
+
Appwrite
+
Amazon S3
+
AWS Lambda
+
Amazon Bedrock
+
CloudWatch

The most important takeaway for me was that AI becomes much more interesting when it is connected to a real product problem.
Instead of building an isolated AI demo, I wanted to integrate AI into something users already understand: creating and sharing social content.
This project gave me hands-on experience with AWS, serverless architecture, managed AI services, and integrating new cloud capabilities into an existing application.
And this is only the beginning for Snaplit AI. 🚀



Project

Snaplit
Built by Sajan Bisht
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