When we started building Forevers.app, the idea sounded simple:
Take still photos, arrange them into a meaningful story, and turn them into a cinematic AI generated video.
In reality, it became one of the most technically challenging and exciting products we have built.
Forevers.app is an AI video generation platform that helps people bring cherished memories to life. Users upload photos, organize them chronologically, and receive an animated video with transitions, movement, music, and emotional pacing.
Behind that simple experience sits a full stack system involving React, TypeScript, Supabase, Replicate, Mux, Stripe, Remotion, Fabric.js, background jobs, multilingual UI, credit logic, admin tooling, and a lot of edge cases we did not expect at the beginning.
This is a look at what we built, what broke, what worked, and what is coming next.
The product vision
The goal was not just to create another AI tool.
We wanted Forevers.app to feel personal.
Most people have hundreds or thousands of photos sitting on their phone or cloud storage. Some are from family events, memorials, weddings, birthdays, travel, childhood moments, or loved ones they want to remember.
The problem is that photos are static. They are meaningful, but they do not always feel alive.
Forevers.app turns those images into short cinematic videos using AI powered animation and transitions. The user does not need editing skills, timeline knowledge, video software, or prompt engineering.
Upload photos. Arrange them. Generate a video.
That is the promise.
The stack we chose
For the frontend, we built with:
React 19
TypeScript
Vite
Tailwind CSS
React Router
TanStack Query
Framer Motion
Fabric.js
Remotion
Radix UI and shadcn/ui
For the backend and infrastructure:
Supabase for auth, database, and edge functions
Replicate for AI model inference
Mux for video hosting and delivery
Stripe for payments and credits
Supabase Storage for file handling
This stack gave us speed, flexibility, and enough control to build both a consumer friendly product and a strong admin system.
The first big challenge: AI video generation is not one job
At first, it is easy to think video generation means sending one request to an AI model and getting one video back.
That is not how it works.
A full video generation pipeline contains many smaller steps:
Photo upload
Image validation
Ordering and timeline logic
Clip generation
Prediction tracking
Transition generation
Merge processing
Music generation
Audio looping
Muxing
Final delivery
Error recovery
Credit deduction
Admin visibility
Each step can fail independently.
One clip might succeed while another fails. A merge job might timeout. A video might be generated successfully but fail during upload. A user might close the browser halfway through. A payment might succeed while the video pipeline is still running.
So we had to stop thinking about video generation as a single request and start treating it as a state machine.
That changed everything.
What we learned about long running AI jobs
AI jobs are slow, unpredictable, and expensive.
That means the product must be designed around uncertainty.
We had to think carefully about:
When to charge credits
How to show progress
How to retry failed jobs
How to avoid duplicate generations
How to handle partial success
How to expose useful errors to admins
How to prevent users from feeling stuck
The biggest lesson was this:
A good AI product is not only about model quality. It is about job orchestration.
Users care about the final result, but they also care about trust. They need to know something is happening. Admins need to know what went wrong. The system needs to recover gracefully.
That led us to build a more complete admin dashboard with user management, video job monitoring, model probing, credit controls, payment visibility, coupon management, branding configuration, CMS controls, and support tooling.
The frontend challenge: simple UI, complex state
The user interface had to feel simple.
But under the hood, the state was anything but simple.
A project can have many photos. Photos can be reordered. Each photo can become a clip. Each clip can have a prediction state. A project can be draft, processing, failed, partially completed, or completed.
We used TanStack Query heavily for fetching, caching, and keeping the UI responsive. We also used Framer Motion to make interactions feel smooth, especially around project flows and transitions.
Fabric.js helped with canvas manipulation, and Remotion gave us a powerful way to think about rendering and composition.
One important product decision was keeping the core flow focused. It is tempting to add too many editing controls, but most users do not want professional video software. They want a beautiful result quickly.
That became a guiding principle:
Powerful system, simple interface.
The multilingual problem
Forevers.app supports English and Hebrew.
That sounds like a translation task, but it is really a layout task too.
Hebrew means RTL support. Components need to adapt. Spacing, alignment, navigation, font loading, and even emotional tone need to feel natural in both languages.
We built language and font handling into the marketing and product experience so the app can support both LTR and RTL flows.
This was especially important because memory based products are emotional. Bad localization makes the product feel generic. Good localization makes it feel personal.
The payment and credit system
We chose a token based credit system because AI generation has real cost.
Every video generation consumes compute, model usage, storage, and delivery resources. So the business model needed to map clearly to usage.
Stripe handles payment processing, while the app manages credits, coupons, history, and admin controls.
One of the harder parts was aligning payment success with generation state. A user should not lose credits because of a system failure. At the same time, the platform needs protection from duplicate jobs and abuse.
That required careful handling around credit deduction, job creation, retry behavior, and admin recovery tools.
What worked well
The biggest success so far is that the product experience feels understandable.
Users do not need to know what Replicate, Mux, Remotion, or Supabase are. They just see their photos become a video.
That abstraction is the product.
Some wins we are proud of:
The generation pipeline is becoming more reliable
The admin dashboard gives real operational visibility
The UI supports both English and Hebrew
The credit system makes usage transparent
The app is structured around features, not random components
The stack allows us to move quickly without giving up control
From a developer perspective, the modular structure helped a lot. Separating marketing, projects, admin functionality, shared UI, providers, and API logic made the app easier to grow.
What did not work at first
A few things were harder than expected.
Progress tracking was more complicated than expected. Users do not want vague loading screens for long AI jobs.
Error states needed more detail. A failed AI job without context is almost impossible to debug.
Admin tooling had to be built much earlier than expected. Once real users interact with AI pipelines, you need visibility immediately.
Video delivery is its own product layer. Generating a video is only part of the work. Hosting, playback, encoding, and delivery matter just as much.
AI cost control must be designed from the beginning. Every retry, failed job, and duplicate request has business impact.
These lessons shaped the platform heavily.
What is coming next
We are now focused on making Forevers.app faster, smarter, and more flexible.
Better generation quality
More cinematic transition styles
Improved music generation and synchronization
Smarter photo ordering suggestions
More customization without overwhelming the user
Better mobile experience
More advanced admin analytics
Additional language support
Template based video stories
Improved recovery for failed jobs
Long term, the goal is to make Forevers.app the easiest way to turn meaningful photos into emotional AI generated videos.
Not just slideshows.
Actual memory stories.
Final thoughts
Building Forevers.app taught us that AI products are not only about calling a model.
The real work is everything around the model:
The user flow
The job system
The error handling
The payments
The admin tools
The delivery pipeline
The emotional experience
AI makes the magic possible, but product engineering makes it usable.
We are still early, but the results so far are exciting. Seeing static memories turn into moving cinematic videos is genuinely powerful.
That is what keeps us building.
You can try it here: