DEV Community: Mushood Hanif

How can you find your target market if you don't know what your product is.

Mushood Hanif — Sun, 01 Feb 2026 11:18:20 +0000

Most people try to find customers before they understand what they’re actually selling.

That’s backwards.

Context changes everything.

This simple philosophy completely changes how we think about automated sales agents. Instead of blasting generic outreach, we let context define who to target, what to say, and why it matters.

In this article, I’ll walk through a 4-part n8n workflow that builds an autonomous, context-aware sales system—from raw product knowledge to hyper-personalized outreach.

The Big Idea

We start by creating a knowledge base that acts as persistent context across the entire workflow.

This context:

Guides AI agents
Improves lead quality
Enables real market research based on what the product actually offers

Think of it as giving your sales agent a memory—because amnesia is bad for revenue.

Use Case

Lead generation for product-based sales

Tech Required

All tools used either have free tiers or are generously priced.

Neon DB – Store research and lead data (Google Sheets works too, but rate limits will eventually ruin your day)
Google Serper – Web search for AI agents
Google Drive – Knowledge base document storage
Pinecone – Vector database for contextual retrieval
Hunter.io – Email discovery for outreach
Email Client – Gmail or any SMTP-capable service
Gemini – Our LLM powering the agents

Good to Know

This entire workflow is:

Low-cost
Scalable
Fully automated
Slightly terrifying (for traditional sales teams)

How It Works (High Level)

Convert your knowledge base into embeddings
Use that context to generate targeted search queries
Research companies and identify decision-makers
Send hyper-personalized outreach emails

Four workflows. One autonomous sales machine.

Step 1 – Context Creation

This workflow synchronizes documents from Google Drive into Pinecone while preventing redundant processing using Google Sheets as a record manager.

1. File Discovery & Filtering

Trigger: Manual or scheduled
Google Drive Integration: Scans a specific folder
Validation:
- IF Node checks whether the item is a folder or a file
- Folders are ignored
- Files move forward for processing

2. Change Detection (State Management)

To save time, tokens, and money:

Hashing:
- Generate a SHA256 hash of the file contents
Record Lookup:
- Check Google Sheets for existing file IDs and hashes
Switch Logic:
- New file → Process & store
- Hash changed → Re-process & update
- Hash unchanged → Skip

Efficiency is the real growth hack.

3. Data Ingestion & Vectorization

Data Loading:
- Download file and extract text
Text Splitting:
- Recursive Character Splitter
- 1000 characters per chunk
- 10-character overlap
Embedding:
- Google Gemini Embedding Model converts chunks into vectors

4. Vector Storage

Pinecone:
- Upserts embeddings + metadata (file name, ID)
Namespacing:
- Clears namespace to ensure updated docs replace old ones

This workflow runs once, or whenever new documents are added.

Step 2 – Lead Generation

This workflow turns product knowledge into qualified company leads—not random internet noise.

1. Strategy Generation (The “Brain”)

Trigger: Scheduled (daily or weekly)
Lead Criteria Agent:
- Gemini analyzes the Pinecone knowledge base
Output:
- Structured JSON defining:
- Ideal industries (e.g., FinTech, HealthTech)
- Company size
- High-intent Google search queries
- Queries are optimized to find company websites, not blogs

2. Automated Web Research

Loop: Iterates through generated queries
Google Serper:
- Executes live searches
- Uses negative operators (-site:medium.com, -site:linkedin.com, etc.)

No listicles. No influencers. Just businesses.

3. Data Parsing & Scoring

Code Node (JavaScript):
- Removes “Top 10” list pages
- Identifies real company homepages
- Scores results based on:
- /products or /solutions pages
- Extracts:
- Clean company name
- Domain

4. Database Integration & De-duplication

Postgres Check:
- Pulls existing companies
Filtering:
- Discards duplicates
Insert:
- Saves only new, high-quality leads into the search table

Step 3 – Contact Generation

Now we turn companies into actual humans you can email.

1. Lead Retrieval & Throttling

Trigger: Daily
Database Query:
- Fetch up to 5 unprocessed companies
Wait Nodes:
- Throttle API calls to avoid rate limits

Patience is cheaper than API overages.

2. Deep Company Research (AI Analyst)

Company Research Agent (Gemini):
- Uses:
- Google Serper (news, competitors, challenges)
- Pinecone (product-feature matching)
Output:
- Structured JSON with:
- Industry pain points
- Custom use cases
- Why this company needs your product

3. Contact Enrichment (Finding the “Who”)

Hunter.io:
- Finds emails and LinkedIn profiles
Decision Maker Filtering:
- Extracts:
- Names
- Titles
- Verified emails
- Removes null or generic results

4. Final Data Storage

Validation:
- Ensure at least one valid email exists
Insert:
- Save enriched leads into the leads table
Status Update:
- Mark company as processed to avoid repeats

Step 4 – Outreach

This is where everything comes together.

1. Lead Selection

Trigger: Daily at 2 AM
Database Query:
- Fetch up to 5 leads with no sent_date
Batching:
- Process leads one by one for quality

2. AI Copywriting (The Personalization Agent)

Context Injection:
- Prospect name & title
- Deep company research
- Product knowledge (via Pinecone)
Prompt Instructions:
- 150–200 words
- Professional, friendly tone
- Written as the CEO
- References:
- Specific company news
- Industry challenges
- Relevant product features

No “Hope this email finds you well.”

3. Automated Sending (Gmail)

Parser:
- Ensures clean JSON:
- Subject
- HTML body
- CTA
Gmail Integration:
- Sends email directly from your account

4. Closing the Loop

Database Update:
- Save sent_date
- Store full email_content
Result:
- No duplicate outreach
- Full audit trail for sales

The End-to-End Result

You’ve built a fully autonomous sales department:

Workflow 1: Syncs product knowledge
Workflow 2: Finds companies that need it
Workflow 3: Identifies decision-makers
Workflow 4: Sends personalized outreach emails

All driven by context.
All running on autopilot.

Sales, but make it intelligent.

How to Setup n8n for Free.

Mushood Hanif — Tue, 22 Jul 2025 19:49:52 +0000

This article is to serve as a guide to help the reader setup n8n for free with all the features unlocked. This article will provide a step-by-step guide on how to setup your n8n from the start to the end.

Introduction
Prerequisites
- Database
Deployment
Usage
Caveats

Introduction

n8n is a no-code automation creation platform that helps people develop workflow automations for anything they can imagine and any scenario. n8n can be used in 2 ways:

Purchase it directly on the website: n8n can be purchased directly from n8n.io and you can unlock all of their features and use it completely in all it’s glory.
Self-host your own n8n image: n8n can be self-hosted on your personal servers and it will provide all of the features unlocked and for free. There are no drawbacks to this method and this can be upgraded if required.

This article will be a step-by-step guide to self-hosting your own n8n service using already existing, state-of-the-art, free software online.

Prerequisites

To start, we need to have 2 things in our inventory:

Database: Self-hosted n8n services require a database to be connected to it for storing all your workflows, credentials and information. We will employ neon.tech as our database.
Backend Deployment Service: The way we will self-host our own n8n service is to utilize the open-source and free n8n docker image provided by n8n.io themselves. This docker image will be hosted on render.com which is a free backend deployment service that allows for free deployment of docker images as well.

Database

To setup or free database, we:

Need to visit neon.tech and create an account. Neon allows the creation of 10 databases in their free tier. Quite generous.
After the creation of the account, we need to create a database. Go to your dashboard and click the New Project button.
Provide your desired database name, select the PostgreSQL version as 17 or whatever the latest version shows up at your side. Select the service provider as AWS or Azure. Select the server location, make sure you select a place that is closer to you.
Submit and you’ll be greeted with the dashboard of the new database you just created. Now all you need to do is to click the Connect button and copy the database_url. It should be something like this: postgresql://neondb_owner:npg_ijsRhYk14rpX@ep-silent-math-aeaiq51s-pooler.c-2.us-east-2.aws.neon.tech/neondb?sslmode=require&channel_binding=require.

The Neon database URL is made up of the following information:

DB_USER: neondb_owner
DB_USER_PASSWORD: npg_ijsRhYk14rpX
DB_HOST: ep-silent-math-aeaiq51s-pooler.c-2.us-east-2.aws.neon.tech
DB_NAME: neondb
DB_PORT: 5432 and the Port that Neon DB uses by default is 5432

This information will come in handy in the following steps.

Instruction Video: https://drive.google.com/file/d/1AsAIm1jTSnSLzwpIxkgrLzMRaKQzS0Ye/view?usp=sharing

Deployment

For deployment, we need to setup render.com for free service deployment:

Visit render.com and create an account.
After the creation of the account, collect the following information in a .txt file:
- DB_POSTGRESDB_DATABASE=neondb
  - This value remains the same. Use it as is.
- DB_POSTGRESDB_HOST=ep-polished-thunder-aejy3eqg-pooler.c-2.us-east-2.aws.neon.tech
  - You get this from your database_url copied from neon
- DB_POSTGRESDB_PASSWORD=npg_KJtpmv6X9Skw
  - You get this from your database_url copied from neon
- DB_POSTGRESDB_PORT=5432
  - This value remains the same. Use it as is.
- DB_POSTGRESDB_SSL=true
  - This value remains the same. Use it as is.
- DB_POSTGRESDB_SSL_CA_FILE=/etc/ssl/certs/ca-certificates.crt
  - This value remains the same. Use it as is.
- DB_POSTGRESDB_SSL_REJECT_UNAUTHORIZED=true
  - This value remains the same. Use it as is.
- DB_POSTGRESDB_USER=neondb_owner
  - You get this from your database_url copied from neon
- DB_TYPE=postgresdb
  - This value remains the same. Use it as is.
- N8N_ENCRYPTION_KEY=62kUtfcV3+R7xk9P5GpQPFT3q9nmTQKxO4p7VXL4de/HeW/Hm62il4H13tnMw6Zd
  - This is a random string used for encryption. It can be anything.
- N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=true
  - This value remains the same. Use it as is.
- N8N_RUNNERS_ENABLED=true
  - This value remains the same. Use it as is.
- WEBHOOK_URL=https://n8n-hdw9.onrender.com/
  - You get this after the first successful deployment on render.com
Once all the values above have been collected, It’s time to deploy your n8n service.
Go to your Dashboard on render.com and click on the Add New button, then select Web Service.
You will be prompted with a few options, select the Existing Image option.
In the Input field below, enter docker.io/n8nio/n8n and click on Connect.
Once the connection is successful, scroll to the Instance Type section and select the Free option.
Then scroll down to the Environment Variables section, then copy and paste all the values you collected previously in a .txt file except for the WEBHOOK_URL value. We will add this after the deployment is successful.
Then click on Deploy Service .
Once, the service is deployed, open your newly deployed instance, and copy the URL that render.com assigned to your instance.
The find the Environment option in the sidebar and click on it.
Find the Environment Variables section and click on the Edit button. Add a new variable and add WEBHOOK_URL=<the-copied-url-of-your-newly-deployed-service> to it and save. This will start the redeployment of your service.

Instruction Video: https://drive.google.com/file/d/1uztybutDLOlHYVhU2JbIkGguJz-hAPup/view?usp=sharing

Usage

Congratulations, you now have your very own, totally free n8n service deployed and ready to use. Now we need to set it up:

You remember the URL you copied at the end for the WEBHOOK_URL value, copy that URL, paste it in your browser and enter. This will open your n8n instance.
When you open your instance, it will ask for your account details, provide those details and submit.
This will take you to your n8n dashboard. Once you reach the dashboard, you’ll be able to see an onboarding form. Don’t skip this form. Fill it and submit it.
Once submitted, you’ll see that n8n will prompt you to enter your email to receive a license key that grants you all the paid and premium features for free. Enter your email and submit.
You’ll receive an email shortly from n8n. Open that email and you’ll find the license key. Copy that license key and go back to your n8n instance.
Find your account settings in the bottom of the sidebar in your n8n dashboard. This will open up a Usage and plan page.
Click on Enter activation key , paste your activation key and press Activate.
You now have a completely free, fully premium n8n service of your own. Happy workflowing!

Instruction Video: https://drive.google.com/file/d/1Bd4AS-n3lbr-erz1I2UtERQ7sz0no4Xz/view?usp=sharing

Caveats

Since the deployment of the service is done on a free server, inactive time will spool down the server on which your n8n service is deployed. When you re-open your n8n service after a time of inactivity, you will face some problems opening your n8n service again. Be patient and try a few times and it will open up.

Accelerating Full‑Stack Development with React Kit

Mushood Hanif — Sat, 28 Jun 2025 21:25:43 +0000

Building a scalable, maintainable application often means juggling multiple repositories, ensuring consistency across front- and back‑end code, and wiring up complex toolchains. React Kit streamlines this process by bundling a modern React frontend and an asynchronous Python FastAPI backend into a single, type‑safe monorepo. Whether you’re prototyping an MVP or laying the groundwork for a production‑grade platform, React Kit gets you up and running in minutes — with best practices baked in.

👉 Explore the repo on GitHub

Why a Monorepo?

Splitting frontend and backend into separate repos can soon become an organizational headache:

Duplicated setup: Separate linting, formatting, and CI configurations.
Sync challenges: API changes on the backend may break frontend code if types drift.
Onboarding friction: New team members must clone and configure multiple projects.

React Kit solves this by colocating code under a single roof, sharing configuration, and enforcing consistent tooling across the stack.

Key Features at a Glance

Type‑Safe Full Stack

Backend: FastAPI + Pydantic v2 ensures strict request/response validation.
Frontend: React + TypeScript with end‑to‑end type safety.
Type Generation: Optional tools like @rtk-query/codegen-openapi can generate TS types directly from your FastAPI OpenAPI schema, eliminating type drift.

Modern Frontend Tooling

Vite for lightning‑fast builds and hot reload.
TanStack Router for file‑based, zero‑config routing with nested layouts.
Redux Toolkit & RTK Query for intuitive state management and data fetching.
Tailwind CSS for utility‑first styling.

Async‑First Backend

FastAPI powers auto‑generated OpenAPI docs (Swagger at /docs).
SQLAlchemy with async support (via asyncpg) for high‑throughput database interactions.
Seed Data: On startup, the backend seeds predefined data from constants/seed_data.json if tables are empty.

Robust Tooling & Automation

Husky Git Hooks enforce linting and formatting at every commit and can auto‑run migrations or dependency installs on merge.
Ruff for Python linting, Black for formatting.
Biome on the frontend for linting and formatting.

Inside the Monorepo

react-kit/
├── backend/                # FastAPI backend
│   ├── app/                # Core code: routers, models, schemas
│   ├── requirements.txt    # Python deps
│   └── .env                # Environment variables
├── frontend/               # React + TypeScript
│   ├── src/                # Routes, store, assets
│   ├── package.json        # JS deps & scripts
│   └── vite.config.ts      # Build config
└── .husky/                 # Git hooks (pre‑commit, post‑merge)

This structure keeps concerns neatly separated while sharing top‑level scripts and configuration files.

Quickstart Guide

1. Clone and Install

git clone https://github.com/DivineDemon/react-kit.git
cd react-kit

2. Backend Setup

cd backend
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env    # configure DATABASE_URL, JWT_SECRET_KEY
uvicorn app.main:app --reload

3. Frontend Setup

cd ../frontend
pnpm install
cp .env.example .env    # set VITE_BASE_API_URL
pnpm run dev

Within moments, you’ll have both servers running with hot reload enabled.

Development Workflow & Best Practices

Coding: Work inside /frontend or /backend; file‑based routing and modular FastAPI routers make feature addition intuitive.
Lint & Format: Pre‑commit hooks automatically run Ruff/Black and ESLint/Prettier on staged changes.
Type Updates: After modifying Pydantic schemas, regenerate TS types via @rtk-query/codegen-openapi to keep frontend in sync.
Database Migrations: While not built‑in, you can augment React Kit with Alembic for versioned migrations.

This workflow minimizes manual steps, letting you focus on building features rather than maintaining boilerplate.

Special Highlights

Automatic API Discovery: All Python modules under app/routers/ are auto‑included in your FastAPI app—no manual imports needed.
Hot‑Reload Everywhere: Both uvicorn and Vite watch for file changes, providing instant feedback loops.
Seeded Demo Data: Fresh database? Just start your backend and watch your tables populate automatically.
Extensible: Swap Postgres for MySQL by updating your DATABASE_URL, or replace RTK Query with React Query—React Kit doesn’t lock you in.

Who Should Use React Kit?

Startup Teams aiming to ship MVPs rapidly with minimal ops overhead.
Full‑Stack Developers who value type safety and end‑to‑end consistency.
Engineering Managers looking for a reproducible boilerplate to onboard new engineers.
Even seasoned teams can benefit by using React Kit as a template for best‑in‑class tooling and workflows.

Next Steps & Contribution

While React Kit comes pre‑wired for most use cases, you can easily extend it:

Add GraphQL by layering Ariadne or Strawberry on top of FastAPI.
Integrate CI/CD pipelines (GitHub Actions templates are a natural fit).
Build a mobile companion using React Native in the same monorepo.
Contributions are welcome — simply fork the repo, implement your enhancements, and submit a pull request. Check out the FAQ and Contributing sections for more details.

Conclusion

React Kit offers a compelling foundation for modern web applications, uniting a type‑safe Python backend and a high‑performance TypeScript frontend under one roof. With automated tooling, robust defaults, and an emphasis on developer experience, it’s an ideal starting point for projects of any scale. Clone the repo today and start building your next full‑stack app with confidence.

🔗 github.com/DivineDemon/react‑kit