DEV Community: Rohit Mahajan

PassThrough: Catch Shoot Expenses Before They Disappear

Rohit Mahajan — Thu, 15 Oct 2026 05:13:59 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge: Week 2 — Side Hustle

What I Built

PassThrough helps freelance photographers and videographers turn shoot expenses into invoice-ready lines.

Parking, travel, props, and rush prints are easy to forget when the job is over. Upload a receipt, attach it to a shoot and client, review the extracted fields, then approve the costs that are billable. Only approved, billable expenses appear in the CSV export.

The model suggests the merchant, date, total, currency, and a short expense description. It does not approve anything or send an invoice. The freelancer checks the source receipt and corrects the fields first.

The person I built this for is a working photographer or videographer who regularly fronts small production costs. Recovering even a few missed expenses could justify paying for a small tool like this. I have not tested that willingness to pay with a customer yet; that is the next thing I need to validate.

Demo

Try PassThrough

The public demo is deployed with Backboard configured. Use sample receipts only: the Render free service can lose stored data after a restart or deploy, and this version is not for sensitive client documents.

Code

PassThrough on GitHub

How I Built It

The app uses Python, FastAPI, SQLite, and a small HTML/CSS/JavaScript interface. Backboard sends receipt images and scanned PDF pages to the configured open-weight Qwen3.5 9B model through OpenRouter. Searchable PDF text is extracted locally, then sent for model processing.

After extraction, ordinary code validates the date, currency, and positive amount. The user reviews each field and decides whether it is billable. The CSV contains only approved billable lines.

flowchart LR
  A[Receipt photo or PDF] --> B[PassThrough web app]
  B -->|Image or scanned page| C[Backboard]
  B -->|Searchable PDF text| C
  C --> D[Qwen3.5 9B via OpenRouter]
  D --> E[Suggested receipt fields]
  E --> F[Human review and code validation]
  F --> G[Workspace expense list]
  F --> H[Approved invoice-line CSV]

Each browser profile gets a separate workspace using a private cookie, and database queries scope receipts to that workspace. This is not account authentication: people sharing one browser profile share its workspace. On local runs, receipt files and records stay in the local data directory. On the hosted demo, they are stored by the Render service and may be ephemeral.

Why Does Open Innovation Matter?

I chose an open-weight model because receipt extraction is a narrow job where I want to be able to change the model without rebuilding the whole product around one proprietary model API. Backboard gives this web demo a hosted way to run the configured model, while leaving the model choice visible and replaceable.

There is a real tradeoff: this is not local inference. Receipt images and scanned pages go to Backboard, and searchable PDF text is sent there too. Hosted inference is easier to demo than asking every freelancer to install a vision model, but it adds provider cost and means the public version is not suitable for confidential receipts. A local inference option would be a separate piece of work, not a feature I’m claiming today.

Prize Categories

Best Use of Backboard
Best Use of Render

Fieldnote: a tiny local AI prompt to help you notice more outside

Rohit Mahajan — Wed, 07 Oct 2026 11:07:03 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Fieldnote is a pocket sized outdoor reflection companion. Write one thing you noticed on a walk a bird call, a patch of moss, wind in the trees and it gives you one short sensory prompt. The goal is to glance at the screen, get curious about your surroundings, and put the phone away.

The local path runs an open-weight model in the browser. If a device cannot run WebGPU, Fieldnote still offers a clearly labeled sample prompt; it does not pretend that the sample came from AI. I also built an explicit hosted-model path for devices that need it. That path sends the note to a Supabase Edge Function and then to Backboard, so it has different privacy and connectivity tradeoffs.

Demo

Try Fieldnote on Render

The first local model load needs a connection to download the model files. After they are cached, local inference can work without sending the note to a model server, on browsers and devices that support WebGPU and have enough memory. My testing also surfaced the limitation: some devices do not expose a compatible GPU, so the local model cannot start there. The hosted fallback is implemented, but I have not yet verified a complete live generation with its production provider credentials; I’m not presenting that route as a confirmed working demo.

Code

Source code on GitHub

The local model/runtime integration is in app.js; the hosted proxy is in supabase/functions/field-prompt/. The repository README covers local setup and deployment.

How I Built It

Fieldnote uses WebLLM to run Qwen2.5-0.5B-Instruct-q4f16_1-MLC with WebGPU in the browser. The model turns a short field note into one safe, one-minute observation prompt. Its system instructions explicitly avoid identifying wildlife or encouraging people to approach it.

The local route keeps the note in the browser. The model files are downloaded on first use and cached by the browser for this site. The app also has a separate hosted route: the browser calls a Supabase Edge Function, which keeps the Backboard credential server-side. Its deployment settings are intended to select google/gemma-3-12b-it through OpenRouter. Hosted generation needs network access and sends the note to the hosted service; it is not private local inference. That route still needs a successful production end-to-end check.

flowchart LR
  A[Notice something outside] --> B[Write a short field note]
  B --> C{Choose a route}
  C -->|Local, compatible WebGPU| D[WebLLM + Qwen in browser]
  C -->|Hosted, explicit opt-in| E[Supabase Edge Function]
  E --> F[Backboard / configured Gemma model]
  D --> G[One-minute field prompt]
  F --> G
  G --> H[Put the phone away]

Why Does Open Innovation Matter?

Open weights and an open browser runtime make the local first version possible: people can use the prompt without sending their observation to an AI provider, and there is no per request model API charge on that path. The small model is also replaceable, so the app can evolve as browser runtimes and compact models improve.

That openness comes with real constraints. WebGPU support, memory, and the initial model download determine whether the local route works on a particular phone. A hosted model can reach more devices, but it needs connectivity, may cost money, and means the user's note leaves the device. I want the app to make that tradeoff visible instead of quietly routing every observation to a server.

Prize Categories

Overall challenge
Best Use of Render (the live frontend is deployed as a Render Static Site)

Exploring Generative AI with the Gemini API in Vertex AI: A Technical Overview

Rohit Mahajan — Thu, 01 Oct 2026 16:25:23 +0000

Generative AI is rapidly reshaping the landscape of artificial intelligence by enabling machines to produce new, original content ranging from text and images to video and beyond.

Google Cloud’s Vertex AI platform now includes the powerful Gemini API, designed to simplify access to state of the art multimodal generative models.

This blog dives into the technical aspects of the Gemini API within Vertex AI, providing insights into its architecture, capabilities, and practical integration strategies for developers and data scientists.

Understanding Gemini API in Vertex AI
At its core, the Gemini API provides programmatic access to Google’s advanced generative AI foundation models. These models are pretrained on massive datasets and fine tuned for multimodal tasks, meaning they can handle text, images, and video seamlessly within a single unified API.

The Gemini API is not a standalone service it’s embedded within Vertex AI, Google Cloud’s end-to-end machine learning platform. This integration offers several benefits:

Unified model management: Use Vertex AI to deploy, monitor, and version control generative models.
Scalability and reliability: Leverage Google Cloud’s infrastructure for high availability and autoscaling.
Security and compliance: Benefit from built-in IAM controls, encryption, and audit logging.

Core Capabilities of Gemini API

Multimodal Generation: Gemini’s models can generate coherent outputs across different media types. For example, you can submit a text prompt and receive an image or video, or vice versa, enabling complex multimodal workflows.
Fine-tuning and Customization: Although the API exposes pretrained models, Vertex AI allows further fine-tuning on custom datasets. This helps tailor outputs to domain-specific vocabulary, style, or content constraints.
Contextual Understanding: Gemini models maintain contextual awareness across inputs, making outputs more relevant and consistent. This feature is especially useful in conversational AI and interactive applications.
High Throughput Predictions: The API is optimized for production workloads, supporting batch and streaming prediction modes, allowing integration into real-time applications and large-scale content pipelines.

Architectural Highlights

Model Abstraction Layer: The API abstracts underlying model complexities, presenting a simplified interface to developers. This means users can focus on designing prompts and workflows rather than managing AI architecture.
Vertex AI Pipeline Integration: Gemini seamlessly integrates with Vertex AI pipelines, enabling automated end-to-end workflows — from data ingestion, preprocessing, model invocation, to post-processing and deployment.
Monitoring and Explainability: Vertex AI’s tooling provides detailed monitoring dashboards, usage analytics, and explainability reports. These features are crucial for maintaining model performance and meeting regulatory requirements.

Integration Best Practices

Prompt Engineering: Since Gemini’s outputs depend heavily on input prompts, invest time in crafting clear and context-rich prompts. Experimentation and iterative refinement help optimize results.
Latency and Cost Management: Balance request complexity and response time by tuning batch sizes and model parameters. Utilize Vertex AI’s cost management tools to monitor usage.
Security Measures: Implement strong authentication and role-based access control via Google Cloud IAM to secure API access, especially when integrating Gemini into customer-facing applications.
Hybrid Workflows: Combine Gemini-generated content with other ML models or business logic in Vertex AI pipelines for richer applications — for example, pairing text generation with sentiment analysis.

Use Cases Where Gemini API Excels

Automated Content Creation: Generate high-quality marketing copy, product descriptions, or social media content with minimal human intervention.
Creative Design Assistance: Assist graphic designers by generating initial image concepts or storyboards from textual briefs.
Conversational AI: Power intelligent virtual assistants capable of understanding and generating nuanced, multimodal responses.
Video and Media Production: Prototype video sequences or multimedia presentations by combining text, images, and video generation.

Conclusion

The Gemini API in Vertex AI offers a technically robust and scalable solution to incorporate generative AI capabilities into modern applications. By abstracting complex model management and providing a unified multimodal interface, it accelerates innovation while maintaining enterprise-grade reliability and security.

As generative AI continues to evolve, leveraging tools like Gemini within a comprehensive platform like Vertex AI positions developers and organizations to lead in AI-driven creativity and automation.