This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.
What I Built
Finding potential clients is one of the most time-consuming activities for freelancers and small software development agencies.
Before approaching a business, we often need to understand what it does, which services it offers, and whether there are opportunities to help improve its digital operations.
Normally, this means opening a website, navigating through several pages, reading the content, and manually preparing research notes.
I wanted to simplify that process using open-weight AI.
So I built LocalLead AI, a lightweight business research assistant that transforms public business websites into structured business intelligence and potential software development opportunities.
How it works:
- Enter a business website URL.
- The application crawls relevant pages, including links discovered through navigation menus and footers.
- It extracts and cleans website content.
- Qwen3-4B summarizes the business information.
- The model identifies possible software and automation opportunities.
- The application generates a structured lead report with supporting source URLs.
- Users can download the extracted information, summaries, and final report as JSON files.
For example, if a clinic's website states that appointments are handled over the phone, LocalLead AI might suggest an online appointment management system.
These recommendations are treated as potential opportunities, not confirmed customer requirements.
Who would pay for it?
LocalLead AI is designed for:
- Freelancers looking for potential clients.
- Software development agencies researching businesses.
- Consultants identifying possible automation opportunities.
- Small sales teams performing initial prospect research.
The potential business model is simple: offer affordable research reports or a subscription that helps users reduce repetitive manual research.
The prototype has not yet been commercially validated, but it targets a real and recurring workflow.
Demo
I built an interactive Gradio interface with a minimal dark theme.
Users enter a website URL and receive a structured analysis containing:
- Business overview
- Business category
- Potential software opportunities
- Supporting sources
- Confidence indicators
- Lead priority
- Downloadable JSON reports
Demo: [Add Gradio demo URL or recorded walkthrough]
The application currently runs inside a Kaggle Notebook using an NVIDIA Tesla T4 GPU.
Because Kaggle sessions are temporary, I recommend watching the recorded demo if the live application is unavailable.
Code
GitHub Repository: [https://github.com/adityagit-creator/AIWebSearch]
The implementation uses Python and standard open-source libraries.
One of my goals was to avoid unnecessary infrastructure and keep the project easy to understand and modify.
The application does not require a separate vector database, autonomous browser framework, or complex agent orchestration layer.
How I Built It
1. Starting with a browser agent idea
My initial inspiration came from the Browser MCP Agent in the Awesome LLM Apps repository.
A general-purpose browser agent is powerful, but I realized that this specific use case did not require a fully autonomous browsing environment.
For an initial business research workflow, a lightweight crawler could handle much of the information collection.
I therefore built a specialized pipeline instead of copying the original agent architecture.
2. Extracting website information
I used Python Requests and BeautifulSoup to retrieve and parse public webpages.
The crawler starts from a business website and discovers additional internal pages.
Navigation menus and footer links are included because useful information may be found on About, Services, Products, and Contact pages.
The application removes unnecessary HTML elements, extracts readable text, and saves the collected information.
The initial version limits extraction to ten pages per website.
3. Choosing an AI model
Initially, I experimented with the Hugging Face Inference API.
However, several models were unavailable through my enabled inference providers, and I eventually exhausted my free inference credits.
Instead of relying on a paid API, I decided to run an open-weight model directly.
I selected Qwen3-4B and loaded it through Hugging Face Transformers and PyTorch in Kaggle.
My development environment provided two NVIDIA Tesla T4 GPUs, but the model was small enough to run on a single GPU.
This removed the need to pay a hosted LLM provider for individual inference requests during development.
4. Summarizing the website
Rather than passing all extracted pages into one large prompt, I created a two-stage analysis process.
Stage A — Page summarization
Qwen3-4B analyzes individual pages to identify:
- Business identity
- Products and services
- Target customers
- Existing digital features
- Booking and contact methods
- Operational information
The individual summaries are saved for later review.
Stage B — Opportunity generation
The model analyzes the collected summaries and produces a structured JSON report with possible software solutions, reasons for suggesting them, source URLs, and confidence labels.
This separation keeps the research process easier to inspect and debug.
5. Building the interface
I used Gradio to create an interactive web application without building a separate frontend.
The interface includes three primary sections:
Overview & Leads: A readable business research report.
Structured Data: The complete JSON analysis.
Export: Downloadable lead reports, page summaries, and extracted website content.
I also customized the UI with a near-black theme, subtle borders, and high-contrast typography.
Technology Stack
| Component | Technology |
|---|---|
| Programming language | Python |
| AI model | Qwen3-4B |
| Model inference | PyTorch + Transformers |
| Compute | Kaggle GPU |
| Website crawling | Requests |
| HTML processing | BeautifulSoup |
| User interface | Gradio |
| Storage and export | JSON |
Why Does Open Innovation Matter?
Open-weight AI is not just an optional component of LocalLead AI. It is the core technology that makes the application useful.
1. Avoiding dependency on proprietary inference APIs
During development, I encountered restrictions with hosted model availability and inference credits.
By switching to Qwen3-4B, I could continue building without purchasing additional API credits.
The model runs directly within my allocated Kaggle environment.
This doesn't make computation universally free, since Kaggle has usage limits and production infrastructure has costs. But it makes experimentation more accessible.
2. Control over the model
Using an open-weight model gives me more control over inference behavior.
I can adjust generation settings, modify prompts, inspect model outputs, and experiment with alternative model architectures.
For example, I can configure temperature and top-p to balance output consistency against variation in suggested business opportunities.
3. Model portability
The application is not permanently tied to one model provider.
The Qwen3-4B inference layer can be replaced with another compatible open-weight model without redesigning the entire website research workflow.
This creates flexibility for future deployment and experimentation.
4. Inspectable research
Rather than returning only a final AI answer, LocalLead AI saves the extracted website content, intermediate summaries, and structured report.
This gives users an opportunity to review the evidence behind the AI-generated recommendations.
A model can still make mistakes, and summaries can omit relevant details. Preserving the source content makes verification easier.
5. A practical path toward a side hustle
A small agency or freelancer may not need an expensive enterprise sales intelligence platform.
A narrowly focused tool that automates the repetitive first stage of prospect research could provide useful value at a lower operating cost.
Open-weight AI makes it possible to experiment with such a business without depending entirely on proprietary model pricing and availability.
Challenges and Lessons Learned
During development, I encountered several issues:
Hugging Face model availability: Some models listed in the catalog were not available through my configured inference providers.
Inference credits: I exhausted my hosted API allowance and moved to Kaggle-hosted model inference.
Transformers generation: I initially encountered an error when passing a BatchEncoding object directly to model.generate(). Passing the token tensors as named arguments fixed the issue.
GPU memory: I configured Qwen3-4B to run on a single Tesla T4 rather than unnecessarily distributing it across two GPUs.
Structured output: Generating valid JSON consistently requires careful prompts and output handling.
UI readability: I redesigned the Gradio export interface after discovering contrast issues with the default file component.
These experiences reinforced an important lesson: a useful AI application doesn't always need the biggest model or the most complicated framework.
Sometimes a focused workflow with a smaller model is enough.
Future Improvements
I plan to improve LocalLead AI by adding:
- Prioritized crawling of About, Services, and Contact pages
- Better handling of JavaScript-rendered websites
- Stronger source verification
- JSON schema validation
- Batch analysis of multiple business websites
- CSV export
- More transparent lead ranking
- Support for interchangeable open-weight models
- Persistent lead history
Before broader public deployment, I also plan to strengthen URL validation, crawling safeguards, and protections against requests to internal network addresses.
Conclusion
LocalLead AI started with a simple question:
Can a lightweight open-weight AI application reduce the repetitive work involved in finding potential software clients?
The prototype demonstrates a practical approach: crawl public business information, summarize it using Qwen3-4B, and convert the results into structured research with potential software opportunities.
For me, the biggest benefit of open innovation is having the flexibility to keep building, experimenting, and improving the product without being locked into a single proprietary inference provider.
That's what makes LocalLead AI an interesting foundation for a potential side hustle.
Built with Python, Qwen3-4B, Kaggle, BeautifulSoup, and Gradio.
Top comments (0)