Projects

PursuitBot
Effortless price tracking for Amazon sellers.
PursuitBot is an effortless monitoring system designed specifically for Amazon sellers. It eliminates the "data chaos" of manual price checking by automatically tracking competitor prices and stock status, delivering clear insights through a clean dashboard.
The Problem: Manual Price War Fatigue
Amazon sellers often spend 20+ hours per week manually checking competitor ASINs. They struggle with:
- Choice Overload → Sifting through endless logs and browser tabs to spot changes.
- Missed Opportunities → Losing sales because a competitor dropped prices while they weren't looking.
- Inventory Blindness → Not knowing when a competitor goes out of stock or returns to market.
- Spreadsheet Hell → Trying to maintain historical trends in messy, manual files.
Sellers should be optimizing their strategy, not refreshing Amazon pages.
The Solution: Autopilot for Competitive Intel
PursuitBot (available at pursuitbot.com) turns raw price checks into actionable signals. It acts as a 24/7 watchtower that records every market move and alerts the seller only when action is needed.
Core Capabilities:
- Smart Tracking → Monitors competitor ASINs for price and inventory changes at the frequency you choose (up to 4x daily).
- Intelligent Alerts → Automatic email notifications for price drops, stock changes, or "back-in-stock" events.
- Visual Analytics → A weekly activity timeline that highlights which brands and categories are most volatile.
- Easy Connectivity → One-click exports to CSV, Google Sheets, or Airtable for custom reporting.
Why It Stands Out
- Multi-Tier Scalability → Designed with flexible plans (Starter, Growth, Scale) to serve everyone from solo sellers to large multi-brand agencies.
- Signal over Noise → Proprietary logic that tracks "total saved" and margin hints, helping sellers prioritize SKUs that deserve their time.
- Bulletproof Automation → Built from the ground up to handle thousands of products across multiple sellers with secure data separation.
- Dead Simple UX → Complex monitoring infrastructure behind the scenes, but a "Set it and Forget it" experience for the user.
The Impact (Real Business Results)
- 20+ Hours Saved → Weekly manual checking eliminated for every active client.
- Optimal Pricing → Real-time data allows sellers to match or beat competitor moves within hours, not days.
- Proven Traction → Currently serving multiple paying clients with a validated subscription model.
- Market Intelligence → Provides a historical record of competitor positioning that was previously impossible to track manually.
Technical Highlights
As the Lead Architect & Developer, I built PursuitBot's backend using a robust automation stack:
- n8n for complex workflow orchestration and scheduled Amazon checks.
- Airtable & Supabase for centralized, high-performance data storage.
- Render for reliable, cloud-based deployment of the automation engine.
My Role: From Ground-Up Build to Scale
I designed and implemented the entire system to be both powerful and scalable.
- Architecture Design → Built the multi-tier monitoring engine that serves concurrent clients with different needs.
- Scraping Strategy → Developed a resilient way to track thousands of ASINs without being blocked.
- Notification Engine → Created the logic for customizable alerts based on price percentage drops and stock thresholds.
.gif%3Falt%3Dmedia%26token%3D0e35c1ef-7030-4304-99f3-573eeb0d2477&w=3840&q=75)
GeoQueryFirestore
Advanced Geospatial Queries for Firestore
GeoQueryFirestore is an open-source Dart package that solves one of Firestore’s biggest limitations: performing performant geospatial queries at scale. It enables developers to filter location-based data with support for pagination, limits, and ordering—features often missing in standard solutions.
The Problem: Firestore's Geo-Query Gap
While Firestore is powerful, its native support for location-based searches is limited. Developers often struggle with:
- No Pagination → Loading thousands of nearby locations at once, causing crashes and high costs.
- Missing Sort/Limit → Inability to retrieve only the "closest 20" items or sort by a secondary field.
- Performance Bottlenecks → High latency when querying large datasets using standard geofence methods.
- Inflexible Ranges → Difficulties in handling custom search radii or map-view boundaries.
Existing tools like GeoFlutterFire provided a start, but couldn't handle production-grade enterprise needs.
The Solution: A Robust Geo-Engine for Dart
GeoQueryFirestore (available on GitHub) operates by intelligently selecting geohash precision based on the search area. It treats location data as a first-class citizen, allowing for complex queries that feel native to Firestore.
Core Capabilities:
- Query by Range → Search within a specific radius (e.g., 10km) with automatic precision adjustment.
- Map Bounds Search → Fetch only the documents currently visible on a user's map screen (LatLngBounds).
- Built-in Pagination → Effortlessly "load more" results as the user scrolls, saving bandwidth and memory.
- Order & Limit → Combine location filters with
limit()andorderBy()to show the most relevant data first.
Why It’s a Game Changer
- Scale-Ready → Specifically designed to handle large datasets where loading everything at once isn't an option.
- Intelligent Precision → Automatically calculates the optimal geohash length to minimize read operations and maximize speed.
- Developer Friendly → A clean, intuitive API that integrates seamlessly with existing
cloud_firestoreprojects. - Customizable → Supports both predefined ranges and custom meter-based search distances.
The Impact (Open Source Contribution)
- Bridged the Gap → Created a solution for features (pagination/ordering) that the community had requested for years.
- Optimization → Reduced unnecessary document reads by optimizing how geohash cells are calculated and queried.
- Public Utility → Provided as a free, open-source package to help Flutter developers build better location-based apps.
Technical Highlights
Built for the Flutter/Dart ecosystem with a focus on performance:
- Geohash Algorithm for converting coordinates into searchable string prefixes.
- Custom Precision Logic to balance search accuracy with query performance.
- Paging Controller logic that automatically tracks document snapshots for seamless "next page" fetches.
- LatLngBounds Filtering for strict boundary adherence in map-heavy applications.
My Role: Creator & Maintainer
I identified the technical gap while building location-heavy products and decided to build and open-source the solution.
- Problem Identification → Recognized the scaling issues with existing Firestore geo-libraries.
- Library Architecture → Designed the core logic for geohash precision and query concatenation.
- Documentation & Examples → Wrote comprehensive guides to help other developers implement complex geo-features in minutes.
The result? A go-to tool for Flutter developers who need reliable, paginated, and fast location queries in Firestore.

FetchLocalDB
Firestore-to-SQLite Sync Bridge
FetchLocalDB is a performance-focused Flutter package designed to solve one of the biggest challenges in cloud-native mobile development: high operational costs. It acts as an intelligent bridge that synchronizes data between Firestore and a local SQLite database, ensuring apps stay fast, reliable, and budget-friendly.
The Problem: The "Cloud Bill" Bottleneck
Scaling a Firebase-backed app often leads to a surge in document read counts, resulting in expensive monthly bills. Developers typically face:
- Sky-High Costs → Constant Firestore reads on every app launch drain the budget.
- Performance Latency → Fetching large datasets over the network causes slow load times.
- Offline Fragility → Apps that rely purely on the cloud break in low-connectivity areas.
- Manual Sync Hell → Writing complex, error-prone logic to handle local caching manually.
The Solution: Intelligently Fresh Data
I built FetchLocalDB (available on GitHub) to automate the "delta-sync" process. It ensures your app only fetches new or changed data, treating your local database as the primary source of truth.
Core Capabilities:
- Delta Fetching → Automatically identifies the latest local record and only requests newer documents from Firestore.
- Smart Synchronization → Handles both new record insertions and background updates to existing local data.
- Offline-First Architecture → Provides an instant-load experience by serving data from SQLite while syncing in the background.
- Custom Bridge Logic → Support for complex Firestore queries and custom update-checking models.
Why It Stands Out
- Cost-Engineering Focus → Explicitly designed to minimize document reads, directly lowering your Google Cloud bill.
- Developer Simplicity → Replaces hundreds of lines of manual sync code with a single, robust
SqlLiteFirestoreBridge. - Reliability at Scale → Built-in handling for date-based and index-based comparisons to ensure zero data loss.
- High Performance → Leverages the speed of local SQLite for UI rendering, making the app feel native and snappy.
The Impact (Optimization Success)
- Bill Reduction → Proven to reduce Firestore read operations by up to 80-90% for data-heavy applications.
- UX Transformation → Converts "loading..." screens into instant interactions by prioritizing local storage.
- Open Source Utility → Providing a production-ready tool for the Flutter community to build sustainable startups.
Technical Highlights
Engineered for the Dart/Flutter ecosystem with an emphasis on durability:
- Bridge Architecture for decoupled communication between local and hosted databases.
- UpdateModel Logic for cross-referencing hosted hashes with local primary keys.
- Timestamp Normalization to handle timezone and epoch conversions between SQLite and Firestore.
- Automated Error Handling for interrupted sync sessions and network failures.
My Role: Creator & Architect
I recognized the financial burden of scaling Firebase apps and developed this package to de-risk growth for independent developers and startups.
- Problem Identification → Analyzed cloud billing patterns to identify the most expensive read-heavy workflows.
- Algorithm Design → Designed the delta-sync algorithm that powers the bridge logic.
- Library Maintenance → Actively maintaining the package and providing documentation for enterprise-grade integrations.
The result? A critical tool for any Flutter developer looking to build high-performance, low-cost mobile applications.








