From Pain Point to Product: Building a Lottie Watermark Remover with AI

In the fast-paced world of product development, small roadblocks can quickly become major frustrations. This is the story of how our team transformed a common design workflow inconvenience into a useful tool — all with the help of AI as our pair programmer.

The Problem: Watermarked Lottie Files

If you work with web animations, you're probably familiar with Lottie files — lightweight, scalable animations that perform beautifully across platforms. Our designers frequently use LottieLab to modify Lottie animations, but encountered a frustrating limitation: exported files contained a watermark unless you paid for a premium subscription.

While the watermark is completely understandable from a business perspective, it created friction in our workflow. We needed a solution that would let us make quick colour adjustments to animations without committing to another subscription service.

Solution 1.0: The Command-Line Script

Rather than accepting this limitation or adding another expense, I decided to examine what was actually happening with these files. Lottie animations are just JSON files with a specific structure, and after analyzing a few watermarked files, I discovered a pattern: the watermark was typically added as a layer with an unusually high index value (ind: 12345679).

With this insight, I asked Gemini 2.5 Pro to create a script that could identify and remove this layer. The AI immediately understood the problem and generated a complete Python script that:

• Loads a Lottie JSON file

• Identifies layers with suspiciously high index values

• Removes those layers

• Exports a clean version with a "_cleaned" suffix

The script worked perfectly on the first try. No more watermarks!

def remove_lottielab_watermark(input_filepath):
    # Load the JSON file
    with open(input_filepath, 'r', encoding='utf-8') as f:
        data = json.load(f)

    # The LottieLab watermark typically has a very high 'ind' value
    watermark_ind_to_remove = 12345679

    # Filter out the watermark layer
    data['layers'] = [layer for layer in data['layers'] 
                      if layer.get('ind') != watermark_ind_to_remove]

    # Save the cleaned file
    output_filepath = f"{os.path.splitext(input_filepath)[0]}_cleaned{os.path.splitext(input_filepath)[1]}"
    with open(output_filepath, 'w', encoding='utf-8') as f:
        json.dump(data, f, separators=(',', ':'))

I wrapped this with a simple bash script that could either use local Python or spin up a Docker container if Python wasn't available. It was a quick, effective solution for our immediate needs.

From Script to Product: The Web App Transformation

While the script solved our internal problem, I recognized that other teams likely faced the same challenge. What if we could make this utility accessible to anyone without requiring them to run scripts or Docker containers?

With that product mindset, I decided to build a simple web application using Next.js. Once again, I turned to AI assistance — this time using Claude and Cursor to help generate the code, with V0 for UI enhancement suggestions.

In less than an hour, we had created a fully functional web app that:

• Provides a drag-and-drop interface for uploading Lottie JSON files

• Processes the file in the browser to remove watermarks

• Shows a side-by-side preview of original vs. cleaned animations

• Allows users to download the watermark-free version

The core functionality remained the same, but we transformed the experience from a developer-focused command line tool to a user-friendly web application that designers could use directly.

The Power of AI in Building Niche Tools

This project highlights several important lessons about modern software development:

1. Problem-Focused Thinking

Rather than accepting limitations, we identified a specific pain point and designed a targeted solution. The initial goal wasn't to build a product — it was simply to solve our own problem efficiently.

2. AI as a Development Partner

AI tools dramatically accelerated the development process:

• Gemini 2.5 Pro generated a working Python script in one shot

• Claude helped build out the web application architecture and component structure

• Cursor assisted with code completion and refinement

• V0 provided UI enhancement suggestions

The most impressive part was how quickly these AI tools understood the context. I didn't need to explain what Lottie files were or how watermarks worked — the models had enough knowledge to immediately grasp the problem and suggest appropriate solutions.

3. From Tool to Product

The transformation from internal script to public-facing web app demonstrates how developers can think beyond immediate solutions. By considering the broader potential audience and improving accessibility, we created something of wider value.

4. Rapid Iteration

The entire process — from initial script to deployed web application — took just a few hours. AI allowed us to iterate quickly, test concepts, and refine the implementation without getting bogged down in research or debugging.

Looking Forward: The AI-Enabled Builder

This experience has changed how I approach development challenges. When facing niche problems, my thought process now includes:

• Can this problem be clearly articulated to an AI? If so, getting to an initial solution can be incredibly fast.

• Does my solution have broader applicability? If others might benefit, consider productizing it.

• How can AI help not just with coding, but with the entire product lifecycle? From ideation to implementation to improvement.

As builders, we're entering an era where the limiting factor isn't our ability to code solutions — it's our ability to identify problems worth solving and to envision how solutions can grow into products. AI tools are particularly valuable for niche use cases where the market might be too small to justify traditional development resources.

The Result: A Free, Open-Source Tool for Everyone

I'm excited to share that our Lottie watermark remover is now publicly available! What started as an internal solution has evolved into a free tool that anyone can use:

• Live Demo: Try it yourself at LottieLab Watermark Remover

• Open Source: The complete code is available on GitHub at this Repository

• Video Tutorial: Check out our YouTube walkthrough to see the tool in action:

By open-sourcing this solution, we hope to help other designers and developers who face the same challenge. The project also serves as an example of how AI-assisted development can lead to practical tools that solve real problems.

Feel free to contribute to the project, suggest improvements, or fork it for your own needs!

Conclusion: Building in the Age of AI

Our Lottie watermark remover may not change the world, but it demonstrates how AI is changing the economics of problem-solving. Tools that would have been too costly or time-consuming to develop just a few years ago can now be created in an afternoon.

For designers and developers in our company, this tool has removed a persistent friction point in their workflow. The fact that we could build it so quickly and make it accessible to non-technical team members shows the potential of AI-assisted development for internal tooling.

The next time you encounter a workflow obstacle or limitation in your tools, consider whether it might be an opportunity to build something new. With AI assistance, the gap between identifying a problem and implementing a solution has never been smaller.

---

What niche tools have you built to solve specific problems in your workflow? How has AI changed your approach to development? Share your experiences in the comments below!