Based on a tutorial by Ras Mic
Ever wondered how to build a profitable SaaS application that actually works? You’re not alone. Many developers struggle with integrating multiple services, handling payments, and creating a seamless user experience.
I’m excited to share this breakdown of Ras Mic’s fantastic tutorial where he builds a complete image generator SaaS in just one day. This isn’t just another coding tutorial – it’s a blueprint for building real, monetizable applications using modern technologies that work beautifully together.
Quick Navigation
- Project Demo & Overview (00:00-02:30)
- Tech Stack Breakdown (02:31-03:45)
- Project Structure & Routing (03:46-05:15)
- Authentication & Backend Setup (05:16-07:00)
- Payment Integration with Polar (07:01-09:30)
- Image Generation with OpenAI (09:31-12:15)
- Convex Scheduled Functions Magic (12:16-14:00)
- Database Schema & Wrap-up (14:01-15:30)
Project Demo & Overview
Ras Mic demonstrates his completed SaaS application that transforms regular photos into Simpsons-style cartoons using GPT’s API. The application charges $3 for 10 image generations and includes a complete dashboard for managing credits and viewing previous generations.
Key Points:
- Complete SaaS with user authentication and payment processing
- $3 pricing model for 10 image generations
- Real-time processing with persistent background tasks
- User dashboard showing credit balance and generation history
- Built in just one day using modern tech stack
My Take:
What’s impressive here isn’t just the final product, but how quickly it was built. This demonstrates the power of choosing the right tools that work well together – something every developer should prioritize when starting a new project.
Tech Stack Breakdown
The application uses a carefully selected modern tech stack that prioritizes developer experience and rapid development. Each technology serves a specific purpose and integrates seamlessly with the others.
Technologies Used:
- React: Frontend framework for building the user interface
- Tanstack Router: Type-safe routing solution
- Clerk: Authentication and user management
- Convex: Backend-as-a-service with real-time capabilities
- Polar: Payment processing and subscription management
- OpenAI API: Image generation and transformation
My Take:
This tech stack is a masterclass in choosing tools that complement each other. Notice how each service handles one thing exceptionally well, reducing the complexity of integration and maintenance.
Project Structure & Routing
The project follows a clean, organized structure using Tanstack Router for type-safe routing. The layout system mimics Next.js patterns while providing more control over the routing logic.
Key Structure Elements:
main.tsx
sets up Clerk, Convex, and Tanstack Router_root.tsx
acts as the layout component (like Next.js layout)- Outlet component renders child routes dynamically
- Homepage contains the main CartoonHero component
- Clean separation between header, content, and footer
// Example route structure
<Route path="/" component={HomePage} />
<Route path="/credits" component={CreditsPage} />
<Route path="/dashboard" component={DashboardPage} />
Authentication & Backend Setup
The integration between Clerk and Convex provides seamless authentication with minimal setup. This connection allows every Convex function to access user information automatically.
Authentication Features:
auth.config.ts
connects Clerk with Convex backend- Every mutation and query automatically receives user ID
- No manual token handling or user session management
- Secure by default with built-in authorization
// Convex function with automatic user access
export const myMutation = mutation({
handler: async (ctx, args) => {
const identity = await ctx.auth.getUserIdentity();
const userId = identity?.subject;
// Now you have access to the authenticated user
}
});
My Take:
This authentication setup is brilliant because it eliminates the boilerplate code you’d normally write for user management. The automatic user ID injection into every function is a game-changer for productivity.
Payment Integration with Polar
Polar handles the entire payment flow with minimal code. The webhook system automatically processes payments and updates user credits, making the integration incredibly smooth.
Payment Flow:
- Fixed $3 payment for 10 image generation credits
- Webhook endpoint at
/payment/webhook
processes transactions - Automatic credit allocation when payment succeeds
- Event tracking for order updates and payment failures
- Metadata system passes user ID and purchase details
// Simple Polar checkout creation
const checkout = await polar.checkouts.create({
productId: PRODUCT_ID,
successUrl: SUCCESS_URL,
customerEmail: userEmail,
metadata: {
userId: user.id,
purchaseType: "image_pack",
quantity: 10
}
});
My Take:
The simplicity of Polar’s API is refreshing. Compare this to setting up Stripe webhooks and handling all the edge cases – Polar abstracts away the complexity while maintaining full control over the payment flow.
Image Generation with OpenAI
The core functionality uses OpenAI’s image editing API with a carefully crafted prompt to transform uploaded photos into cartoon styles. The implementation includes proper error handling and response validation.
Image Processing Flow:
- User uploads image through Convex’s file upload system
- Custom prompt optimized for cartoon-style transformations
- OpenAI’s
images.edit
API processes the transformation - Internal actions ensure secure API calls
- Proper image data validation and error handling
// OpenAI image transformation
const response = await openai.images.edit({
model: "dall-e-2",
image: imageFile,
prompt: `You're a world-class professional artist specializing in
cartoon-style transformations. Transform this image into a
Simpsons-style cartoon while maintaining the person's key features...`,
n: 1,
size: "1024x1024"
});
My Take:
The use of internal actions is a security best practice that many developers overlook. By preventing direct client access to the OpenAI API, you maintain control over usage and costs while keeping API keys secure.
Convex Scheduled Functions Magic
The real magic happens with Convex’s scheduled functions. This allows the image processing to continue even if the user refreshes the page or closes their browser, creating a truly robust user experience.
Scheduled Function Benefits:
- Background processing that survives page refreshes
- Zero-delay scheduling for immediate task execution
- Automatic status updates when processing completes
- No risk of losing work due to client disconnection
- Seamless user experience with real-time status updates
// Schedule immediate background processing
await ctx.scheduler.runAfter(0, internal.imageGen, {
imageId: image._id,
userId: identity.subject
});
// Return success immediately while processing continues
return {
success: true,
status: "processing"
};
My Take:
This is where Convex really shines. Traditional setups require complex queue systems or risk losing work if something goes wrong. Convex makes background processing feel natural and reliable.
Database Schema & Wrap-up
The project includes a clean database schema with proper table definitions and supporting queries. Ras Mic emphasizes how well these technologies work together and plans to open-source the complete codebase.
Project Highlights:
- Complete SaaS built in just one day
- Open-source codebase will be available as a template
- Excellent AI assistance experience with Windsurf and Cursor
- React + Convex + Polar = powerful combination
- No hallucinations when working with AI coding assistants
My Take:
The speed of development here is remarkable, but it’s not just about the tools – it’s about choosing tools that work harmoniously together. This project is a perfect example of how the right tech stack can accelerate development without sacrificing quality.