Day 1 – February 09, 2026

Date: February 09, 2026
Week: 22
Internship: AI/ML Intern at SynerSense Pvt. Ltd.
Mentor: Praveen Kulkarni Sir

Welcome to another exciting chapter in my AI/ML internship journey! Today marks the beginning of Week 22, and I’m diving deep into the AnanaCare Relabel project – a fascinating initiative that combines computer vision, user experience design, and software engineering best practices. This project represents a perfect blend of the theoretical knowledge I’ve been building throughout my internship and real-world application development.

As I reflect on the past weeks, I’ve transitioned from foundational learning to hands-on problem-solving. The AnanaCare Relabel project isn’t just about technical implementation; it’s about creating tools that make complex AI workflows more accessible and efficient. Today, I’m focusing on two critical aspects: automating the development setup process and architecting an intuitive Undo/Redo system for drag-and-drop interactions.

The automation challenge emerged from observing how manual setup processes can become significant barriers to productivity. Imagine a developer spending precious time wrestling with dependency management and environment configuration instead of focusing on the core AI/ML problems. That’s where our “single-click” installer concept comes in – transforming a potentially frustrating setup experience into something seamless and empowering.

Project Status Report: Phase 1 Automation

1. Completed Milestone: Infrastructure Definition

After extensive analysis and experimentation, we’ve established the fundamental architecture that will guide our development process. Moving away from error-prone manual commands, we’ve created a robust framework that ensures consistency and reliability across different development environments.

The backend, powered by FastAPI, serves as the intelligent core of our application, handling complex image processing and annotation logic on port 8000. Meanwhile, our Vite + React frontend on port 3000 provides an intuitive interface for users to interact with the AI-powered relabeling system. By mandating uv as our dependency manager with the uv.lock file ensuring reproducible environments, we’ve eliminated the “works on my machine” syndrome that plagues so many development teams.

Our Windows-only .bat wrapper represents a bold commitment to user experience – a single script that orchestrates the entire application lifecycle from repository synchronization to full system launch.

2. Implementation Plan: The “Single-Click” Installer

The journey toward this automated solution wasn’t straightforward. We initially explored various approaches, from complex shell scripts to containerized solutions, but ultimately landed on a Windows batch file strategy that prioritizes accessibility and minimal system requirements.

Deployment Strategy (`start.bat`)

Stage	Logic	Tooling
Check	Detects if `git`, `uv`, and `node` are installed.	`winget` (for auto-installing missing engines)
Sync	If `.git` exists: `git pull`. If not: `git clone`.	Git CLI
Install	Runs `uv sync` and `npm install`.	`uv` & `npm`
Launch	Concurrent execution of `api.py` and `npm run dev`.	`start_all.py`

Note on Bundling: To ensure this is a true “single-click” experience without pre-requisites, the .bat will use winget to silently fetch Python and Node.js if the user’s system is bare.

This approach represents more than just technical convenience – it’s about democratizing access to advanced AI tools. By removing technical barriers, we’re enabling more people to contribute to and benefit from AI-driven solutions.

Feature Architecture: Undo/Redo System

One of the most fascinating challenges in this project has been designing an intuitive Undo/Redo system for the drag-and-drop annotation interface. This isn’t just about technical implementation – it’s about understanding human behavior and creating tools that feel natural and forgiving.

The drag-and-drop system allows users to precisely position annotation points on images, but what happens when they make a mistake? Or when they want to experiment with different arrangements? A robust Undo/Redo system transforms a potentially frustrating experience into an empowering one, encouraging exploration and iteration.

To implement this feature, we’re drawing from proven software design patterns while adapting them to the specific needs of our computer vision workflow. The Command Pattern combined with a State Stack provides a solid foundation that can handle complex state changes while maintaining performance.

1. State Management (Frontend)

Our React-based frontend will maintain a sophisticated state management system with two carefully orchestrated stacks:

Undo Stack: A chronological record of point coordinates captured at the moment before each change, serving as our safety net for reversals.
Redo Stack: A temporary holding area for states that have been undone, allowing users to reconsider their decisions.

This dual-stack approach ensures that users can freely experiment with different annotation configurations without fear of losing their work.

2. Interaction Logic

The key insight that shaped our interaction design was the recognition that not every microscopic movement during a drag operation should be recorded. Users expect Undo/Redo to work at the level of intentional actions, not pixel-by-pixel adjustments.

To satisfy the requirement that only the final position of a drag is recorded:

onDragStart: We capture the current coordinates as the “original” state – this becomes our reference point for determining if a meaningful change occurred.
onDragEnd: Here’s where the intelligence kicks in:
1. We compare the new position to the original coordinates.
2. Only if a meaningful change has occurred do we push the original position to the Undo Stack.
3. We clear the Redo Stack, as any previous “undone” actions are now invalidated by this new action.
Undo Action: A seamless operation that pops the most recent state from the Undo Stack, pushes the current state to Redo for potential recovery, and applies the restored state.
Redo Action: The inverse operation, allowing users to reapply actions they’ve previously undone.

3. Proposed Data Structure

{
  history: {
    past: [ [{id: 1, x: 10, y: 20}, ...] ], // Array of snapshots
    present: [{id: 1, x: 15, y: 25}, ...],  // Current points
    future: []                              // Redo snapshots
  }
}

This structure draws inspiration from modern state management libraries while being specifically tailored to our annotation use case. The separation of concerns between past, present, and future states makes the logic both powerful and maintainable.

Next Steps

As I look ahead, I’m excited about the implementation phase that lies before us. The architectural planning we’ve completed today sets a strong foundation, but the real magic will happen when these ideas come to life in working code.

Deliver start.bat & setup.py: I’ll craft comprehensive scripts that not only automate the setup process but also serve as documentation of our infrastructure decisions. These scripts will be more than utilities – they’ll be learning tools that demonstrate best practices in cross-platform development.
Integrate winget: The automatic dependency installation logic will be a testament to our commitment to accessibility. By leveraging Windows’ package management capabilities, we’re removing technical barriers and making advanced AI tools available to a broader audience.
Undo/Redo Implementation: Once our automation foundation is solid, we’ll bring the drag-and-drop enhancement to life. This will involve careful integration with our existing React components, ensuring that the new functionality feels like a natural extension rather than an add-on.

The coming weeks promise to be a thrilling blend of technical implementation and user experience refinement. Each line of code we write brings us closer to creating tools that don’t just work, but delight and empower their users. The AnanaCare Relabel project is evolving from a technical exercise into a demonstration of how thoughtful design can transform complex workflows into intuitive experiences.