DEV Community: Kirill Strelnikov

5 CRM Automations That Save 10+ Hours Per Week

Kirill Strelnikov — Fri, 27 Mar 2026 20:11:14 +0000

5 CRM automations that save your team 10+ hours per week. Lead routing, follow-up sequences, data entry, reporting, and churn alerts. Real examples.
CRMAutomationProductivityBusiness
Kirill Strelnikov
— AI Systems Architect, Barcelona

Most CRM users barely scratch the surface of what their system can do. I have seen sales teams spend 2-3 hours per day on manual CRM tasks that should be automated. As someone who builds CRM integrations and business automation solutions, here are the five automations that consistently save the most time.
Automation 1: Intelligent Lead Routing (saves 3+ hours/week)
The manual process:

A manager reviews each new lead, checks the territory/industry/deal size, and manually assigns it to the right sales rep. This happens 20-50 times per day in a busy B2B company. It creates bottlenecks and delays first response time.
The automated process:

New leads are automatically scored and routed based on rules you define:

Geography: European leads go to EU sales team, US leads to US team
Deal size: Enterprise leads (>EUR 50K) go to senior reps
Industry: SaaS leads go to the rep who specializes in SaaS
Lead score: Hot leads (score >80) get immediate attention from top performers
Round-robin: Equal distribution when rules do not apply

Result: leads get assigned in seconds instead of hours. First response time drops from 4 hours to under 15 minutes.
Automation 2: Follow-Up Sequences (saves 2+ hours/week)
The manual process:

Sales reps manually remember to follow up with prospects. They write individual emails, forget some leads, and have inconsistent messaging. Studies show 80% of deals require 5+ follow-ups, but most reps give up after 2.
The automated process:

Automated email sequences triggered by specific events:

New lead created -> Welcome email + value proposition (Day 0)
No response -> Follow-up with case study (Day 3)
Still no response -> Different angle, social proof (Day 7)
Opens but no reply -> Direct ask for meeting (Day 10)
Meeting completed -> Proposal follow-up sequence (Day 1 after meeting)

The sequence stops when the prospect replies or books a meeting. Personalization variables pull data from the CRM: name, company, industry, pain point mentioned on the website.
Automation 3: Data Entry and Enrichment (saves 2+ hours/week)
The manual process:

Reps manually enter data from emails, forms, and calls into the CRM. They Google companies to find missing information like employee count, industry, and revenue. Data quality suffers because reps skip fields.
The automated process:

Email parsing: New emails from contacts automatically logged to the CRM timeline
Form data: Website forms create or update CRM records instantly
Company enrichment: When a new company is added, automatically pull data from clearbit, LinkedIn, or company registries
Call logging: Phone system integration that logs call duration, outcome, and notes
Duplicate detection: Automatically merge duplicate contacts based on email matching

Automation 4: Weekly Pipeline Reports (saves 1.5+ hours/week)
The manual process:

A manager spends Monday morning pulling data from the CRM, creating a spreadsheet, calculating pipeline metrics, and sending a report to the team and leadership. By the time it is done, the data is already outdated.
The automated process:

Every Monday at 9:00 AM, an automated report is generated and sent via email or Slack:

Pipeline value by stage with week-over-week changes
Deals stuck in stage for more than X days (at-risk deals)
Individual rep performance (new leads, meetings, closed deals)
Win/loss rate by source, industry, and deal size
Forecast vs actual for the current quarter

No manual work required. Leadership gets real-time data every week.
Automation 5: Churn Risk Alerts (saves 1.5+ hours/week)
The manual process:

Customer success managers check each account periodically, looking for signs of churn: support tickets, login frequency, feature usage. With 50+ accounts each, they miss warning signs until it is too late.
The automated process:

A churn scoring system monitors multiple signals and alerts the account manager when risk increases:

Support tickets: More than 3 tickets in 30 days -> risk score +20
Login frequency: 50% drop in weekly logins -> risk score +25
Feature usage: Key features not used in 14 days -> risk score +15
Payment: Failed payment or downgrade request -> risk score +30
NPS score: Detractor (0-6) on last survey -> risk score +20

When the risk score exceeds a threshold, the account manager gets a Slack alert with specific details: "Acme Corp risk score 65/100 -- 5 support tickets this month, 40% login drop, key feature unused for 12 days." This enables proactive outreach before the customer churns.
Implementation Cost and Timeline

Each automation typically takes 1-3 days to implement:

Lead routing: EUR 500-1,500 (1-2 days)
Follow-up sequences: EUR 500-1,000 (1-2 days)
Data enrichment: EUR 1,000-2,000 (2-3 days)
Automated reports: EUR 500-1,500 (1-2 days)
Churn alerts: EUR 1,000-2,500 (2-3 days)

Most businesses start with lead routing and follow-up sequences (biggest time savings), then add the others incrementally.

I build these CRM automations for European businesses using HubSpot, Salesforce, and Pipedrive. Book a free automation audit and I will identify the highest-ROI automations for your team.

Django REST API Patterns for Scalable Apps

Kirill Strelnikov — Mon, 23 Mar 2026 15:31:34 +0000

Explore Django REST API design patterns for building scalable applications. Learn practical tips and code examples.
DjangoREST APIScalable ApplicationsDesign PatternsDevelopment
Kirill Strelnikov
— AI Systems Architect, Barcelona
Introduction

Designing a REST API with Django that can handle growth efficiently is crucial for any application. Whether you are building a simple service or a complex system, following best practices in API design can help ensure scalability and performance. This guide will cover essential design patterns and practical tips to create robust and scalable Django REST APIs.
Understanding REST API Design Principles

Before diving into specific patterns, it's essential to understand the guiding principles of REST architecture. REST, or Representational State Transfer, relies on stateless communication and uses standard HTTP methods such as GET, POST, PUT, and DELETE. The key principles include:

Statelessness: Each request from client to server must contain all the information needed to understand and process the request.
Client-Server Architecture: Separation of concerns is achieved by having the client and server handle different aspects of the application.
Cacheability: Responses must define themselves as cacheable or not to prevent clients from reusing stale or inappropriate data.
Layered System: A client cannot ordinarily tell whether it is connected directly to the end server or an intermediary.

Essential Django REST API Design Patterns

Let's explore some design patterns that can help make your Django REST API more scalable:

Use of Generic Views

Django REST Framework (DRF) provides powerful tools for creating RESTful APIs, including generic views that reduce boilerplate code. Generic views like ListCreateAPIView and RetrieveUpdateDestroyAPIView can be used to handle common database operations.

from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView
from .models import MyModel
from .serializers import MyModelSerializer

class MyModelListCreateView(ListCreateAPIView):
queryset = MyModel.objects.all()
serializer_class = MyModelSerializer

class MyModelRetrieveUpdateDestroyView(RetrieveUpdateDestroyAPIView):
queryset = MyModel.objects.all()
serializer_class = MyModelSerializer

Efficient QuerySet Usage

Understanding and optimizing QuerySets can significantly improve performance. Use select_related and prefetch_related to reduce the number of queries:

queryset = MyModel.objects.select_related('related_model').all()

This approach helps decrease database load, a critical factor in scaling applications.

Pagination and Filtering

Implementing pagination and filtering not only improves user experience but also reduces server load. DRF supports pagination out of the box. Here’s how you can set it up:

from rest_framework.pagination import PageNumberPagination

class StandardResultsSetPagination(PageNumberPagination):
page_size = 10
page_size_query_param = 'page_size'
max_page_size = 100

Enable pagination in your views:

class MyModelListCreateView(ListCreateAPIView):
queryset = MyModel.objects.all()
serializer_class = MyModelSerializer
pagination_class = StandardResultsSetPagination

Caching Strategies

Caching can dramatically decrease the time taken to serve API responses. Django offers several caching backends like in-memory, file-based, and database caching. Here is an example of setting up a simple cache:

from django.views.decorators.cache import cache_page

@cache_page(60 * 15)
def my_view(request):
# view code here...

Implementing caching strategies can be a game-changer, especially for read-heavy applications.
Advanced Concepts for Scalability

Beyond basic patterns, there are advanced concepts to consider for highly scalable Django REST APIs:

Asynchronous Task Queues

For operations that require heavy lifting, such as sending emails or processing images, use asynchronous task queues like Celery. This offloads tasks to background workers, freeing up resources for immediate requests.

Rate Limiting

To protect your API from abuse and ensure fair usage, implement rate limiting. DRF integrates well with Django’s built-in throttling classes.

from rest_framework.throttling import UserRateThrottle

class BurstRateThrottle(UserRateThrottle):
rate = '5/minute'

Microservices Architecture

Consider breaking down your application into microservices if it's growing rapidly. This allows you to scale components independently, improving resiliency and efficiency.

For instance, integrating an AI chatbot development service into your architecture can significantly enhance interactivity and responsiveness, leveraging the benefits of microservices.
Conclusion

By applying these design patterns and principles, you can build Django REST APIs that are not only scalable but also maintainable and efficient. As your application grows, revisiting and refining these patterns can help ensure consistent performance and reliability.

If you need expert guidance, consider reaching out for my development services or hire a Django developer in Barcelona to assist you with advanced solutions.

Ready to scale your Django application with expert solutions?
Get in touch →

Build a Production RAG Chatbot with Django + pgvector + OpenAI (Full Guide)

Kirill Strelnikov — Mon, 09 Mar 2026 01:20:00 +0000

I'm Kirill Strelnikov, a freelance AI/Django developer in Barcelona. I've built RAG chatbots that automated 70% of customer support for e-commerce clients. This is a practical guide to building a production-ready RAG chatbot with Django, pgvector, and OpenAI — not a toy demo, but the actual architecture I use in client projects.

What is RAG and Why It Matters

RAG (Retrieval-Augmented Generation) = vector search + LLM. Instead of hoping the LLM "knows" your business data, you:

Store your documents as vector embeddings
When a user asks a question, find the most relevant documents
Feed those documents to the LLM as context
The LLM generates an answer based on YOUR data

Why RAG beats fine-tuning for business chatbots:

No retraining when data changes (just re-embed)
Works with any LLM (swap GPT-4 for Claude without rebuilding)
Answers are grounded in real documents (reduces hallucination)
You can show sources ("Based on: Return Policy, Section 3")

Step 1: Set Up pgvector in Django

pgvector is a PostgreSQL extension for vector similarity search. No separate vector database needed — your embeddings live alongside your regular data.

# Install pgvector on PostgreSQL
# Ubuntu/Debian:
sudo apt install postgresql-16-pgvector

# Or via Docker:
# Use image: pgvector/pgvector:pg16

pip install pgvector django-pgvector

# models.py
from pgvector.django import VectorField

class Document(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    source = models.CharField(max_length=255)  # "faq", "product", "policy"
    embedding = VectorField(dimensions=1536)    # text-embedding-3-small
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        indexes = [
            models.Index(fields=["source"]),
        ]

    def __str__(self):
        return self.title

# migration: enable pgvector extension
from django.db import migrations

class Migration(migrations.Migration):
    dependencies = [("chatbot", "0001_initial")]
    operations = [
        migrations.RunSQL(
            "CREATE EXTENSION IF NOT EXISTS vector;",
            reverse_sql="DROP EXTENSION IF EXISTS vector;"
        ),
    ]

Step 2: Embed Your Documents

# embeddings.py
from openai import OpenAI

client = OpenAI()

def get_embedding(text: str) -> list[float]:
    """Get embedding vector for a text string."""
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

def chunk_text(text: str, chunk_size: int = 300, overlap: int = 50) -> list[str]:
    """Split text into overlapping chunks by token count (approximate)."""
    words = text.split()
    chunks = []
    for i in range(0, len(words), chunk_size - overlap):
        chunk = " ".join(words[i:i + chunk_size])
        if chunk.strip():
            chunks.append(chunk)
    return chunks

def embed_document(title: str, content: str, source: str):
    """Chunk a document and store each chunk with its embedding."""
    chunks = chunk_text(content)
    documents = []
    for i, chunk in enumerate(chunks):
        embedding = get_embedding(chunk)
        documents.append(
            Document(
                title=f"{title} (part {i+1})",
                content=chunk,
                source=source,
                embedding=embedding,
            )
        )
    Document.objects.bulk_create(documents)
    return len(documents)

Chunking matters. I use 300-token chunks with 50-token overlap. Too small = lost context. Too large = diluted relevance. This size works well for FAQ and product data. For longer documents (legal, technical docs), I increase to 500 tokens.

Step 3: Vector Search

# search.py
from pgvector.django import CosineDistance

def search_documents(query: str, top_k: int = 5, source: str = None):
    """Find the most relevant documents for a query."""
    query_embedding = get_embedding(query)

    qs = Document.objects.annotate(
        distance=CosineDistance("embedding", query_embedding)
    )

    if source:
        qs = qs.filter(source=source)

    return qs.order_by("distance")[:top_k]

pgvector's cosine distance search is fast enough for most business chatbots (sub-100ms for 100K documents). For larger datasets, add an IVFFlat or HNSW index:

# migration for HNSW index (faster search for large datasets)
migrations.RunSQL(
    "CREATE INDEX ON chatbot_document USING hnsw (embedding vector_cosine_ops);",
)

Step 4: Generate Answers

# chatbot.py
from openai import OpenAI

client = OpenAI()

SYSTEM_PROMPT = """You are a helpful customer support assistant.
Answer questions using ONLY the provided context.
If the context doesn't contain the answer, say "I don't have information about that. Let me connect you with a human agent."
Always be concise and helpful. Cite the source document when relevant."""

def get_chatbot_response(user_message: str, conversation_history: list = None):
    """Generate a chatbot response using RAG."""
    # 1. Retrieve relevant documents
    relevant_docs = search_documents(user_message, top_k=5)

    # 2. Build context string
    context_parts = []
    sources = []
    for doc in relevant_docs:
        context_parts.append(f"[{doc.title}]: {doc.content}")
        sources.append(doc.title)

    context = "\n\n".join(context_parts)

    # 3. Build messages
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT + f"\n\nContext:\n{context}"}
    ]

    # Add conversation history for multi-turn
    if conversation_history:
        messages.extend(conversation_history[-6:])  # Last 3 exchanges

    messages.append({"role": "user", "content": user_message})

    # 4. Generate response
    response = client.chat.completions.create(
        model="gpt-4",
        messages=messages,
        temperature=0.3,  # Low temperature = more factual
        max_tokens=500,
    )

    answer = response.choices[0].message.content

    # 5. Confidence check
    min_distance = relevant_docs[0].distance if relevant_docs else 1.0
    needs_escalation = min_distance > 0.4  # Threshold tuned per project

    return {
        "answer": answer,
        "sources": sources,
        "needs_escalation": needs_escalation,
        "confidence": round(1 - min_distance, 2),
    }

Step 5: Django REST API

# views.py
from rest_framework.decorators import api_view
from rest_framework.response import Response

@api_view(["POST"])
def chat(request):
    message = request.data.get("message", "").strip()
    session_id = request.data.get("session_id")

    if not message:
        return Response({"error": "Message required"}, status=400)

    # Get conversation history from session
    history = get_session_history(session_id)

    # Generate response
    result = get_chatbot_response(message, history)

    # Save to history
    save_to_history(session_id, message, result["answer"])

    # If low confidence, notify human agent
    if result["needs_escalation"]:
        notify_agent(session_id, message, result)

    return Response({
        "answer": result["answer"],
        "sources": result["sources"],
        "confidence": result["confidence"],
    })

Step 6: Keep Embeddings Fresh

# tasks.py (Celery)
from celery import shared_task

@shared_task
def refresh_product_embeddings():
    """Re-embed products that changed since last sync."""
    from shop.models import Product

    for product in Product.objects.filter(updated_at__gte=last_sync_time()):
        content = f"{product.name}. {product.description}. Price: {product.price} EUR."
        # Delete old embeddings
        Document.objects.filter(
            source="product",
            title__startswith=product.name
        ).delete()
        # Create new ones
        embed_document(product.name, content, source="product")

Schedule this with Celery Beat to run hourly or on product updates.

Production Results

From my e-commerce client project:

Metric	Value
Documents embedded	~2,000 chunks
Avg search latency	45ms
Answer accuracy	~92% (human-evaluated)
Support automation rate	70%
Conversion rate increase	+35%
Monthly API cost	EUR 50-80

The 70% automation rate means 7 out of 10 customer questions are answered correctly without human intervention. The remaining 30% get escalated with full context, so the human agent can resolve them faster too.

Common Pitfalls

Embedding stale data. If your product catalog changes, your chatbot answers are wrong. Automate re-embedding.
No confidence threshold. Without escalation logic, the chatbot will confidently hallucinate. Always add a distance threshold.
Ignoring conversation context. A user asking "what about the blue one?" after asking about a dress needs multi-turn context. Pass conversation history.
Using a separate vector DB for small datasets. pgvector handles 100K+ documents easily. You don't need Pinecone or Weaviate until you hit millions.

Cost to Build

Scope	Timeline	Cost
Basic RAG chatbot (FAQ only)	1-2 weeks	EUR 800-1,500
RAG + product catalog + CRM	2-4 weeks	EUR 1,500-3,000
Multi-channel (web + Telegram + WhatsApp)	4-6 weeks	EUR 3,000-5,000

Detailed pricing: AI Chatbot Development Cost

I'm Kirill Strelnikov — I build production RAG chatbots, SaaS platforms, and Telegram bots as a freelance developer in Barcelona, Spain. 15+ projects delivered, EU-based, GDPR-compliant.

Website: kirweb.site
Telegram: @KirBcn
More AI case studies: kirweb.site/ai-chatbots

The Django SaaS MVP Stack I Use in 2026 (Ships in 4-6 Weeks)

Kirill Strelnikov — Mon, 09 Mar 2026 01:19:35 +0000

I'm Kirill Strelnikov, a freelance Python/Django developer in Barcelona. I've built 5+ SaaS platforms with Django — from time-tracking systems for restaurant chains to multi-tenant platforms with Stripe billing. Here's the exact stack and architecture I use in 2026 to ship SaaS MVPs in 4-6 weeks.

The Stack

Django 5.x          → Web framework (admin, auth, ORM, REST)
PostgreSQL 16       → Primary database (with schema-per-tenant)
Redis               → Cache, sessions, Celery broker
Celery              → Background tasks, scheduled jobs
Django REST Framework → API layer
Stripe              → Subscription billing
Docker + Nginx      → Deployment
Gunicorn            → WSGI server

This isn't theoretical. Every component here has been battle-tested across real projects with paying customers.

Why Django for SaaS (Still, in 2026)

I get asked "why not FastAPI?" or "why not Node.js?" constantly. Here's my honest take after building with all three:

Django gives you 60% of a SaaS for free:

Authentication + permissions (including social auth via django-allauth)
Admin panel (your first "back office" dashboard — free)
ORM with migrations (schema changes without SQL)
Form validation and CSRF protection
Session management
Built-in security middleware

With FastAPI, you build all of that yourself. FastAPI is great for microservices and high-throughput APIs. But for a SaaS MVP where you need auth, admin, billing, and a dashboard? Django saves 2-3 weeks of development.

I wrote a detailed comparison: Django vs FastAPI for SaaS

Multi-Tenant Architecture

For SaaS, you need tenant isolation. I use schema-per-tenant with django-tenants:

# settings.py
DATABASES = {
    "default": {
        "ENGINE": "django_tenants.postgresql_backend",
        "NAME": "saas_db",
    }
}

TENANT_MODEL = "customers.Client"
TENANT_DOMAIN_MODEL = "customers.Domain"

SHARED_APPS = [
    "django_tenants",
    "customers",       # Tenant management
    "django.contrib.admin",
    "django.contrib.auth",
]

TENANT_APPS = [
    "core",            # Your SaaS app
    "billing",
    "analytics",
]

Each tenant gets their own PostgreSQL schema. Data isolation is guaranteed at the database level — no WHERE tenant_id = X scattered through your code.

Real example: I built a time-tracking SaaS for a chain of 5 cafes in Barcelona. Each cafe is a separate tenant with its own employees, shifts, and payroll data. Result: 80% reduction in payroll processing time across all locations.

Stripe Billing Pattern

Every SaaS needs billing. Here's my standard Stripe integration:

# billing/models.py
class Subscription(models.Model):
    tenant = models.OneToOneField(Client, on_delete=models.CASCADE)
    stripe_customer_id = models.CharField(max_length=255)
    stripe_subscription_id = models.CharField(max_length=255, blank=True)
    plan = models.CharField(
        max_length=20,
        choices=[("free", "Free"), ("pro", "Pro"), ("business", "Business")]
    )
    status = models.CharField(max_length=20, default="active")

# billing/webhooks.py
@csrf_exempt
def stripe_webhook(request):
    payload = request.body
    sig = request.META.get("HTTP_STRIPE_SIGNATURE")
    event = stripe.Webhook.construct_event(payload, sig, WEBHOOK_SECRET)

    if event.type == "invoice.paid":
        handle_successful_payment(event.data.object)
    elif event.type == "customer.subscription.deleted":
        handle_cancellation(event.data.object)

    return HttpResponse(status=200)

I always use webhooks instead of polling. Stripe sends events in real-time — your app reacts immediately.

Background Tasks with Celery

SaaS apps need background processing: sending emails, generating reports, syncing data. Celery handles all of this:

# tasks.py
@shared_task
def generate_monthly_report(tenant_id: int):
    tenant = Client.objects.get(id=tenant_id)
    with tenant_context(tenant):
        data = aggregate_monthly_metrics()
        pdf = render_report_pdf(data)
        send_report_email(tenant.owner.email, pdf)

# Scheduled task (Celery Beat)
CELERY_BEAT_SCHEDULE = {
    "monthly-reports": {
        "task": "tasks.generate_monthly_report_all",
        "schedule": crontab(day_of_month=1, hour=6),
    },
}

Deployment: Docker + Nginx + Gunicorn

# docker-compose.yml
services:
  web:
    build: .
    command: gunicorn config.wsgi:application --bind 0.0.0.0:8000 --workers 3
    volumes:
      - static:/app/static
    depends_on:
      - db
      - redis

  db:
    image: postgres:16
    volumes:
      - pgdata:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine

  celery:
    build: .
    command: celery -A config worker -l info

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - static:/app/static
      - ./nginx.conf:/etc/nginx/conf.d/default.conf

One docker compose up and your entire stack is running. Same on development, staging, and production.

Timeline: 4-6 Weeks to MVP

Week	Deliverable
1	Project setup, multi-tenant config, auth, basic models
2	Core features (the thing your SaaS actually does)
3	Dashboard, admin panel, REST API
4	Stripe billing, subscription management
5	Deployment, monitoring, load testing
6	Buffer for feedback and iterations

Week 2 is the only week that varies between projects. Everything else is a repeatable pattern I've refined over 5+ SaaS builds.

Cost

Based on my project history:

Tier	What you get	Cost	Timeline
Basic MVP	Auth, core feature, admin, basic billing	EUR 1,500-4,000	3-4 weeks
Standard	Multi-tenant, Stripe, dashboard, API	EUR 4,000-10,000	5-8 weeks
Enterprise	Custom integrations, analytics, multi-region	EUR 10,000+	8-12 weeks

Detailed breakdown: SaaS MVP Development Cost

Common Mistakes I See

Building auth from scratch. Use django-allauth. It handles email verification, social login, password reset, and 2FA. Don't reinvent this.
Skipping multi-tenancy early. Adding tenant isolation to an existing codebase is painful. Start with django-tenants from day 1.
No background tasks. Everything runs in the request cycle. First heavy operation = timeout. Add Celery from the start.
Over-engineering the MVP. Your first version needs: auth, one core feature, billing, and a way to contact you. Ship that. Iterate after real users give feedback.

I'm Kirill Strelnikov — freelance Python/Django developer in Barcelona, Spain. I build SaaS platforms, AI chatbots, and Telegram bots. 15+ projects delivered across Europe.

Website: kirweb.site
Telegram: @KirBcn
SaaS launch checklist: 50 things before going live Author: Kirill Strelnikov Published: March 11, 2026 Original source: kirweb.site

How I Automated 70% of Customer Support with an AI Chatbot (Django + OpenAI)

Kirill Strelnikov — Thu, 05 Mar 2026 06:32:15 +0000

I'm Kirill Strelnikov, a freelance Python/Django developer based in Barcelona, Spain. I build AI-powered products for businesses across Europe. This is a real case study from a client project.

The Problem

An e-commerce clothing store was drowning in repetitive support tickets: "Where is my order?", "What's your return policy?", "Do you have size X in stock?" — the same 15-20 questions making up 80% of all inquiries. Two full-time support agents were spending most of their day copy-pasting answers.

The client asked me to build an AI chatbot that could handle these repetitive queries automatically, while escalating complex issues to human agents.

The Solution: RAG Chatbot with Django + OpenAI

I built a Retrieval-Augmented Generation (RAG) chatbot — not a simple FAQ bot, but one that understands context and generates natural answers from the store's actual data.

Architecture

User message
  → Django backend (receives via REST API)
  → Vector search (pgvector) finds relevant docs
  → OpenAI GPT-4 generates answer using retrieved context
  → Response sent back to user
  → If confidence < threshold → escalate to human

Key technical decisions:

pgvector for embeddings — stored product catalog, FAQ, and policy documents as vector embeddings directly in PostgreSQL. No separate vector DB needed.
Chunking strategy — split documents into 300-token chunks with 50-token overlap. This gave the best retrieval accuracy for product-related queries.
Confidence scoring — each response gets a confidence score. Below 0.7 → automatic escalation to human agent with full conversation context.
Django admin integration — the client's team can update FAQ entries, add product info, and review chatbot conversations through Django admin. No developer needed for content updates.

The code pattern (simplified)

from openai import OpenAI
from pgvector.django import CosineDistance

def get_chatbot_response(user_message: str) -> dict:
    client = OpenAI()

    # 1. Create embedding for user's question
    embedding = client.embeddings.create(
        model="text-embedding-3-small",
        input=user_message
    ).data[0].embedding

    # 2. Find relevant documents via vector search
    relevant_docs = (
        Document.objects
        .annotate(distance=CosineDistance("embedding", embedding))
        .order_by("distance")[:5]
    )

    context = "\n".join(doc.content for doc in relevant_docs)

    # 3. Generate response with context
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": f"Answer using this context:\n{context}"},
            {"role": "user", "content": user_message}
        ],
        temperature=0.3
    )

    return {
        "answer": response.choices[0].message.content,
        "confidence": relevant_docs[0].distance if relevant_docs else 0,
        "sources": [doc.title for doc in relevant_docs]
    }

Results After 3 Months

Metric	Before	After
Automated inquiries	0%	70%
Avg response time	4 hours	8 seconds
Conversion rate	baseline	+35%
Support staff needed	2 full-time	1 part-time

The 35% conversion increase was unexpected — turns out, instant answers to "is this in stock?" and "what size should I get?" directly drive purchases. Customers who got instant chatbot answers were far more likely to complete checkout.

What I Learned

RAG beats fine-tuning for business chatbots. The client's product catalog changes weekly. With RAG, you just re-embed the new data. No retraining needed.
Confidence-based escalation is critical. The chatbot knows when it doesn't know. This prevents hallucination and maintains customer trust.
Django admin is your secret weapon. Non-technical staff can manage the knowledge base. This makes the chatbot self-sustaining.
Start with the top 20 questions. Don't try to automate everything. The Pareto principle applies: 20% of question types cover 80% of volume.

Cost Breakdown

Development: ~EUR 2,500 (3 weeks)
OpenAI API: ~EUR 50-80/month at their volume
Hosting (Django + PostgreSQL): ~EUR 30/month
ROI: Paid for itself in month 1 (saved 1.5 FTE support salary)

Tech Stack

Python 3.12, Django 5.0, Django REST Framework
PostgreSQL with pgvector extension
OpenAI GPT-4 + text-embedding-3-small
Celery for async embedding updates
Docker for deployment

I'm Kirill Strelnikov — I build AI chatbots, SaaS platforms, and Telegram bots as a freelance developer in Barcelona. If you have a similar project, feel free to reach out:

Website: kirweb.site
Telegram: @KirBcn
Email: Kir.S100@protonmail.com

More case studies: kirweb.site/services

How My Telegram Bot Got 500 Paying Users in 3 Months (Python + aiogram)

Kirill Strelnikov — Thu, 05 Mar 2026 05:30:24 +0000

I'm Kirill Strelnikov, a freelance developer in Barcelona. I build Telegram bots, AI chatbots, and SaaS platforms. This is the story of a Telegram AI aggregator bot I built that hit 500 paying users in 3 months — and was profitable from month 1.

The Idea

The client wanted a Telegram bot that aggregates multiple AI models (GPT-4, Claude, Gemini) into a single chat interface. Users pick a model, send a message, get a response — all without leaving Telegram. The monetization model: credit-based billing.

Simple concept. The execution is where it gets interesting.

Architecture

Telegram user
  → aiogram bot handler
  → Django backend (REST API)
  → Credit system checks balance
  → Route to selected AI model (OpenAI / Anthropic / Google)
  → Stream response back to Telegram
  → Deduct credits

Key components:

1. Credit-based billing system

class UserCredits(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    balance = models.DecimalField(max_digits=10, decimal_places=2, default=0)

    def deduct(self, model: str, tokens: int) -> bool:
        cost = self.calculate_cost(model, tokens)
        if self.balance >= cost:
            self.balance -= cost
            self.save(update_fields=["balance"])
            CreditTransaction.objects.create(
                user=self.user, amount=-cost,
                model=model, tokens=tokens
            )
            return True
        return False

    def calculate_cost(self, model: str, tokens: int) -> Decimal:
        rates = {
            "gpt-4": Decimal("0.003"),      # per 1K tokens
            "gpt-3.5": Decimal("0.0005"),
            "claude-3": Decimal("0.002"),
            "gemini": Decimal("0.001"),
        }
        return rates.get(model, Decimal("0.002")) * (tokens / 1000)

2. Multi-model router

Each AI provider has its own adapter class. The router picks the right one based on user selection:

class ModelRouter:
    adapters = {
        "gpt-4": OpenAIAdapter,
        "claude-3": AnthropicAdapter,
        "gemini": GoogleAdapter,
    }

    async def generate(self, model: str, messages: list) -> str:
        adapter = self.adapters[model]()
        return await adapter.chat(messages)

3. Telegram payment integration

Users buy credits directly in Telegram using Stripe:

@router.message(Command("buy"))
async def buy_credits(message: Message):
    prices = [
        LabeledPrice(label="100 credits", amount=499),   # $4.99
        LabeledPrice(label="500 credits", amount=1999),   # $19.99
        LabeledPrice(label="2000 credits", amount=5999),  # $59.99
    ]
    # Send Telegram invoice
    await message.answer_invoice(
        title="AI Credits",
        description="Credits for AI model usage",
        payload="credits_purchase",
        provider_token=STRIPE_TOKEN,
        currency="USD",
        prices=[prices[0]],  # Default package
    )

Growth Metrics

Month	Users	Paying users	Revenue	MRR
1	800	85	$1,200	$1,200
2	2,100	280	$3,800	$3,800
3	3,500	500	$6,200	$6,200

Conversion rate: ~14% free-to-paid (industry average for bots is 2-5%).

Why so high? Free tier gives 20 credits — enough to try all models but not enough for daily use. The "aha moment" happens when users compare GPT-4 vs Claude on the same prompt. Once they see the value of model switching, they pay.

What Made It Work

1. Telegram's 900M+ user base

No app to install. No signup form. Users just open the bot and start chatting. The friction-to-value ratio is unbeatable.

2. Credit-based pricing (not subscription)

Users pay for what they use. Heavy users spend $20-60/month. Light users spend $5. Nobody feels locked into a subscription they don't use. This increased retention significantly vs subscription-only models.

3. Message open rates: 80%+

Telegram notifications actually get read. When we sent "New model added: Claude 3 Opus" — 82% open rate. Compare that to email marketing (20-25%).

4. Viral inline mode

Users can use the bot inline in any chat: type @botname what is Django? in a group chat and get an AI answer. This drove organic growth — other group members see the bot in action and try it themselves.

Tech Stack

Bot framework: Python 3.12 + aiogram 3.x (async)
Backend: Django 5.0 + Django REST Framework
Database: PostgreSQL (user accounts, credits, transactions)
Cache: Redis (rate limiting, session data)
Task queue: Celery (webhook processing, analytics)
AI providers: OpenAI, Anthropic, Google AI APIs
Payments: Stripe via Telegram Payments API
Deployment: Docker + Nginx on a VPS

Lessons Learned

Monetize from day 1. Don't wait for "enough users." The free tier should be a taste, not a full meal.
Credits > subscriptions for bots. Bot usage is spiky. People use it heavily for a week, then pause. Credits accommodate this pattern naturally.
Telegram bots are underrated as a business channel. 900M+ MAU, 80%+ open rates, built-in payments, inline sharing. For many use cases, a Telegram bot is better than a mobile app.
Multi-model is the moat. Any single-model wrapper gets commoditized instantly. The value is in comparison and switching between models.

Cost to Build Something Similar

Based on my experience building this and similar bots:

Complexity	Timeline	Cost
Simple bot (1 model, basic billing)	1-2 weeks	EUR 500-1,000
Multi-model with credits	3-4 weeks	EUR 1,500-3,000
Full platform with admin, analytics	5-8 weeks	EUR 3,000-6,000

I'm Kirill Strelnikov, freelance Python developer in Barcelona, Spain. I build Telegram bots, AI chatbots, and SaaS platforms for businesses across Europe. 15+ projects delivered.

Website: kirweb.site
Telegram: @KirBcn
Cost guide: How much does a Telegram bot cost?

Freelancer vs Agency: Real Cost Comparison for Software Projects in Europe (2026)

Kirill Strelnikov — Thu, 05 Mar 2026 05:28:27 +0000

I'm Kirill Strelnikov, a freelance Python developer based in Barcelona, Spain. I've been on both sides — working at agencies and now running my own freelance practice with 15+ delivered projects. Here's an honest cost comparison based on real European market rates in 2026.

The Three Options

When you need software built, you have three choices:

Freelancer — one person, direct communication
Agency — team with project manager, designers, developers
In-house hire — full-time employee on your payroll

Each has a clear sweet spot. Let me show you when each makes sense, with real numbers.

Cost Comparison Table

Factor	Freelancer	Agency	In-House
Hourly rate (Europe)	EUR 40-100	EUR 80-200	EUR 30-70 (salary equiv.)
Simple chatbot (2 weeks)	EUR 800-2,000	EUR 3,000-8,000	N/A (hiring takes longer)
SaaS MVP (6 weeks)	EUR 3,000-10,000	EUR 15,000-50,000	~EUR 12,000 (salary only)
Telegram bot (1-2 weeks)	EUR 500-1,500	EUR 2,000-5,000	N/A
Communication overhead	Low (direct)	High (via PM)	Low (direct)
Time to start	Days	2-4 weeks	2-3 months
Scalability	Limited	High	Slow

The key insight: For projects under EUR 25,000, a senior freelancer almost always delivers better value than an agency. The agency's overhead (project managers, office, sales team) adds 2-3x to the cost without proportional quality improvement.

When to Hire a Freelancer

Best for: Projects with a clear scope, EUR 500-25,000 budget, and need for fast delivery.

Advantages:

Direct communication. You talk to the person writing your code. No telephone game through project managers.
Lower cost. No agency overhead. A EUR 80/hour freelancer costs you EUR 80/hour. A EUR 80/hour agency developer costs you EUR 160/hour after the agency's margin.
Faster iteration. Decision to code to deployment in days, not weeks.
Personal accountability. One person owns the entire project. No "that's not my department."

Risks:

Bus factor of 1 (mitigated by clean code and documentation)
Limited to one person's skill set
Availability gaps if they take on too many clients

Real example: I built an AI chatbot for an e-commerce store in 3 weeks for EUR 2,500. An agency quoted the same client EUR 8,000 for a 6-week timeline. Same deliverable. The chatbot automated 70% of customer support and increased conversions by 35%.

When to Hire an Agency

Best for: Large projects (EUR 50,000+), need for multiple specialists simultaneously (design + frontend + backend + mobile), or when you need ongoing team augmentation.

Advantages:

Multiple specialists available immediately
Project management included
Continuity if one developer leaves
Can scale team up/down

Risks:

2-3x higher cost
Communication through intermediaries
Developer turnover mid-project
Incentive to extend timelines

When to Hire In-House

Best for: Core product development that will need continuous work for 12+ months.

Cost reality in Europe:

Junior developer salary: EUR 30,000-45,000/year
Senior developer salary: EUR 55,000-85,000/year
Add ~30-40% for taxes, benefits, equipment: EUR 70,000-120,000/year total cost
Plus: 2-3 months to hire, onboarding time, management overhead

Hire in-house when: The project IS your business (you're a tech company) and you need continuous development for years. Don't hire full-time for a one-off project.

Decision Framework

Is your project scope clear and under EUR 25,000?
  YES → Freelancer

Do you need 3+ different specialists simultaneously?
  YES → Agency

Will you need continuous development for 12+ months?
  YES → In-house

Still unsure?
  → Start with a freelancer for the MVP, then decide

How to Evaluate a Freelancer

After hiring many freelancers myself (at agencies) and now being one, here are the real signals:

Green flags:

Published portfolio with real case studies (not just "beautiful designs" but actual business results)
Fixed-price quotes (means they've done similar projects before and can estimate accurately)
Asks detailed questions before quoting (understands the problem before proposing a solution)
Transparent about limitations ("I don't do mobile apps, but I can recommend someone")
Communication speed (if they take 3 days to respond to your inquiry, imagine mid-project)

Red flags:

Only shows "personal projects" with no client work
Can't provide a fixed estimate ("it depends" for everything)
Hourly-only billing with no cap
No deployment/DevOps experience (they can code but can't ship)
Wants to start coding before understanding your business

Pricing Models Compared

Model	Freelancer	Agency
Fixed price	Common (EUR 500-25,000)	Rare (EUR 10,000+)
Hourly	EUR 40-100/hr	EUR 80-200/hr
Monthly retainer	EUR 500-3,000/mo	EUR 3,000-15,000/mo
Milestone-based	Common (30/30/40)	Sometimes

I use milestone-based fixed pricing: 30% upfront, 30% at midpoint demo, 40% on delivery. This aligns incentives — I want to finish fast, you want to pay for results, not hours.

My Rates (For Reference)

As a freelance Python/Django developer with 5+ years and 15+ projects:

Service	Fixed Price
AI Chatbot	EUR 800-3,000
Telegram Bot	EUR 500-2,500
SaaS MVP	EUR 1,500-10,000
Backend/API	EUR 1,000-6,000
WhatsApp Bot	EUR 500-2,000

Free consultation included. I scope the project, give a fixed quote, and stick to it.

Bottom Line

For most startups and SMBs building their first product:

Start with a freelancer for the MVP (EUR 1,500-10,000, 4-8 weeks)
Validate with real users before investing more
Scale to agency or in-house only when you've proven product-market fit

The biggest waste of money I see: companies spending EUR 50,000 at an agency for an MVP that nobody uses. Build small, test fast, iterate.

I'm Kirill Strelnikov — freelance Python/Django developer and AI engineer in Barcelona, Spain. 15+ projects delivered for clients across Europe. Registered autónomo, EU invoicing, GDPR-compliant.

Website: kirweb.site
Telegram: @KirBcn
Full comparison: Freelancer vs Agency vs In-House
Cost guides: kirweb.site/cost-guides

Custom CRM vs Off-the-Shelf: Which Is Right for Your Business?

Kirill Strelnikov — Fri, 27 Feb 2026 05:33:56 +0000

Custom CRM vs Off-the-Shelf: Which Is Right for Your Business?

Every growing business eventually outgrows spreadsheets and needs a CRM (Customer Relationship Management) system. The first decision is whether to use an off-the-shelf solution like Salesforce, HubSpot, or Pipedrive, or to build a custom CRM tailored to your specific workflow. Both have their place — and choosing wrong can cost you thousands of euros and months of wasted effort.

Off-the-Shelf CRMs: Pros and Cons

Popular Options and Pricing

| CRM | Starting Price | Best For

| HubSpot | Free (paid from €45/mo) | Marketing-focused businesses, startups

| Salesforce | €25/user/mo | Enterprise, complex sales processes

| Pipedrive | €14/user/mo | Sales teams, pipeline management

| Zoho CRM | €14/user/mo | Budget-conscious, all-in-one needs

| Monday.com CRM | €12/user/mo | Teams already using Monday for PM

Advantages

Immediate availability: Sign up and start using it today.
Proven reliability: Millions of users, battle-tested infrastructure, 99.9% uptime.
Built-in features: Email tracking, reporting, mobile apps, integrations marketplace.
Regular updates: New features and security patches without your involvement.
Support and documentation: Large communities, certified consultants, extensive help docs.

Disadvantages

Monthly costs add up: At €50/user/month for 10 users, you pay €6,000/year — and that is before add-ons. Salesforce implementations routinely cost €50,000–200,000 for mid-size companies when you include customization, training, and consulting.
Forced to adapt your workflow: Off-the-shelf CRMs have opinions about how sales, support, and marketing should work. If your process does not match, you either change your process or fight the tool.
Feature bloat: You pay for hundreds of features but use 20%. The interface is cluttered with options irrelevant to your business.
Limited customization: You can configure fields and workflows, but fundamental changes to how data flows or how the UI works require expensive third-party developers or are simply impossible.
Vendor lock-in: Migrating away from Salesforce or HubSpot is a major project. Your data, automations, and integrations are all tied to their ecosystem.
Per-user pricing: As your team grows, costs scale linearly. Custom CRMs have a fixed hosting cost regardless of user count.

Custom CRM Development: Pros and Cons

Typical Cost Ranges

| Scope | Price Range | Timeline

| Basic CRM (contacts, deals, tasks) | €3,000–8,000 | 3–6 weeks

| Advanced CRM (automations, reporting, integrations) | €8,000–20,000 | 6–12 weeks

| Enterprise CRM (multi-team, advanced analytics, AI) | €20,000+ | 3–6 months

Advantages

Perfect fit for your workflow: Every field, every automation, every view is designed for how your team actually works. No compromises.
No per-user fees: Whether you have 5 users or 500, hosting costs the same €50–200/month.
Full data ownership: Your data lives on your server. No vendor lock-in, no data export limitations.
Unlimited customization: Need a custom dashboard, a unique approval workflow, or integration with an obscure API? You can build anything.
Competitive advantage: Your CRM becomes part of your competitive moat. Competitors cannot replicate a process they cannot see.
AI integration: Add AI features like lead scoring, automated follow-ups, or natural language search — exactly how you want them, without paying for an expensive CRM add-on.

Disadvantages

Higher upfront cost: You pay the full development cost before launch.
Maintenance responsibility: You need to plan for ongoing updates, security patches, and bug fixes. Budget 10–20% of the initial cost per year for maintenance.
Longer time to first use: Even a basic custom CRM takes 3–6 weeks to build, versus signing up for HubSpot in 5 minutes.
No built-in marketplace: Integrations must be built or configured individually.

When to Choose Off-the-Shelf

You have a standard sales process that fits the CRM's model.
Your team is small (under 5 users) and budget is tight.
You need to start immediately with minimal setup.
You primarily need email marketing + basic pipeline tracking (HubSpot free tier).
You do not have specific workflow requirements that differ from industry standard.

When to Choose Custom CRM

Your business process is unique and does not fit standard CRM workflows.
You have 10+ users and the per-user SaaS cost is becoming significant.
You need deep integrations with internal tools, ERPs, or industry-specific systems.
Data privacy regulations require you to keep data on your own infrastructure.
You want AI features (auto-classification, lead scoring, smart follow-ups) without paying enterprise SaaS prices.
You have tried an off-the-shelf CRM and find yourself constantly fighting its limitations.

The Middle Ground: CRM Setup and Customization

There is a third option that many businesses overlook: hiring a developer to properly set up and customize an off-the-shelf CRM. Most businesses use less than 30% of their CRM's capabilities because they never configured it properly. A specialist can:

Configure custom fields, pipelines, and views for your specific workflow.
Set up automations (email sequences, task assignment, lead routing).
Build integrations with your other tools via APIs.
Import and clean your existing data.
Train your team on the optimized setup.

This typically costs €500–2,500 and can transform a frustrating CRM experience into a smooth one — without the cost and timeline of a fully custom build.

Making the Decision: A Framework

Map your current workflow — Document exactly how your team handles leads, customers, and deals today.
Try a free tier — Spend one week using HubSpot or Pipedrive's free plan. Does your workflow fit? Where do you hit walls?
Calculate the 3-year cost — Add up SaaS fees, per-user costs, premium add-ons, and integration costs. Compare with custom development + hosting + maintenance.
Consider growth — If you plan to 3x your team in the next two years, per-user pricing becomes very expensive.
Evaluate your unique needs — If more than 30% of your requirements are "custom" or "not available," lean toward custom development.

Conclusion

Off-the-shelf CRMs are the right choice when your needs are standard and your team is small. Custom CRM development makes financial and operational sense when your workflow is unique, your team is growing, or you need capabilities that SaaS products charge enterprise prices for.

I help businesses evaluate and implement both approaches — from CRM setup and customization (starting at €500) to fully custom CRM development. If you are not sure which path is right for your business, let's discuss it.

Originally published on kirweb.site. I build AI chatbots, SaaS platforms, and automation for businesses. Free consultation.

How to Choose a Freelance Developer for Your Startup: A Founder's Checklist

Kirill Strelnikov — Fri, 27 Feb 2026 05:33:03 +0000

How to Choose a Freelance Developer for Your Startup: A Founder's Checklist

Hiring the right freelance developer can make or break your startup's first product. A good hire delivers a working MVP in weeks and becomes a long-term technical partner. A bad hire wastes months and thousands of euros on code that needs to be rewritten. Having worked with dozens of startups as a freelance developer, I have seen both outcomes — and the difference almost always comes down to how the founder approached the hiring process.

Before You Start Searching: Preparation

Define Your MVP Scope

Before contacting any developer, write down exactly what your MVP needs to do. Not what your final product will do — what the minimum version needs. List every feature and mark each as "must-have" or "nice-to-have." A common startup mistake is trying to build the full vision in v1. The result is a project that takes 6 months instead of 6 weeks and burns through the budget before launch.

Set a Realistic Budget

Typical MVP costs in 2026:

Simple web app (CRUD, auth, basic UI): €2,000–5,000
SaaS platform (multi-tenant, billing, dashboards): €4,000–15,000
AI-powered product (chatbot, automation, ML features): €3,000–10,000
Mobile app backend + API: €3,000–8,000
Marketplace/platform: €8,000–25,000

If your budget is significantly below these ranges, reconsider your scope or timeline. Under-budgeting leads to cutting corners on security, testing, and architecture — which costs more to fix later.

Choose Your Tech Stack (or Let the Developer Choose)

If you have a technical co-founder, they likely have stack preferences. If not, trust the developer's recommendation — but make sure they explain the trade-offs. For most startups building web applications, Python/Django or Node.js for the backend and React or Next.js for the frontend is a battle-tested combination. Avoid exotic stacks for your MVP; you want a technology with a large talent pool so you can hire additional developers later.

The Evaluation Checklist

1. Relevant Portfolio (Weight: 30%)

Look for projects similar to yours in complexity and type. A developer who has built three SaaS products will build your SaaS faster and better than someone who has only done static websites, even if the latter charges less. Specific things to check:

Are the portfolio projects live and working? Click through them.
Do case studies mention specific technical decisions and their reasoning?
Are there measurable outcomes (users, performance, revenue impact)?

2. Communication Quality (Weight: 25%)

This is the most underrated factor. During your first conversation, assess:

Do they ask clarifying questions about your project, or just quote a price?
Can they explain technical concepts in plain language?
How quickly do they respond? (Within 24 hours is reasonable; within 2 hours shows they are serious.)
Do they push back on unrealistic expectations, or just say yes to everything?

A developer who says "that's technically possible but I'd recommend a simpler approach for your MVP" is more valuable than one who agrees to build anything you describe.

3. Technical Depth (Weight: 20%)

You do not need to be technical to evaluate this. Ask these questions:

"How would you structure the database for [your main feature]?" — A good developer will think out loud and mention trade-offs.
"What happens when 1,000 users are using the app simultaneously?" — They should mention caching, database optimization, or scaling strategies.
"How do you handle security (authentication, data protection)?" — They should have a clear, standard approach.
"What is your testing strategy?" — Any answer beyond "I test manually" is a good sign.

4. Process and Project Management (Weight: 15%)

Do they use milestones with deliverables?
What project management tool do they use? (Trello, Linear, Notion, etc.)
How often will they send updates?
Do they use version control (Git)? (This should be a given, but ask.)
What is their deployment process?

5. Pricing Transparency (Weight: 10%)

Can they give you a range after hearing your requirements? (A firm quote after a 15-minute conversation is either very experienced or guessing.)
Do they break down the estimate by feature or milestone?
What is included in the price? (Design? Deployment? One month of bug fixes?)
How do they handle scope changes?

Red Flags That Should Make You Walk Away

"I can build anything." — Every good developer has specializations and limitations they are honest about.
No portfolio or NDA on everything. — Some past work may be under NDA, but a developer with zero public work to show is risky.
Price significantly below market. — If everyone else quotes €5,000–8,000 and one person says €1,500, they either do not understand the scope or plan to cut corners.
No questions about your business. — A developer who does not ask about your users, your goals, or your constraints will build the wrong thing.
Refuses milestones or partial payments. — Asking for 100% upfront is a major red flag. Standard structures: 30/30/40 or 50/50.
Cannot show code quality. — Ask for a GitHub profile or a code sample. Clean, well-organized code is a strong signal of professionalism.

Contract and Payment Structure

Essential Contract Elements

Scope of work: Detailed feature list and deliverables.
Timeline: Milestones with dates.
Payment schedule: Tied to milestones, not calendar dates.
IP ownership: You own the code upon payment. This is non-negotiable.
Bug fix period: 30–90 days of free bug fixes after launch.
Termination clause: What happens if either party wants to end the engagement early.

Recommended Payment Structure

30% upfront — Upon signing, to start work.
30% at midpoint — Upon delivery of the first major milestone (working demo).
40% at completion — Upon final delivery and acceptance testing.

After Hiring: Setting Up for Success

Share your full context. Give the developer access to your business plan, competitor analysis, and user research. The more context they have, the better decisions they will make.
Be available. The fastest way to slow down a project is to take three days to answer the developer's questions.
Trust their technical judgment. You hired an expert. If they recommend a different approach than what you imagined, hear them out.
Test early and often. Do not wait until the end to try the product. Use every milestone delivery to test and give feedback.
Plan for post-launch. Your MVP launch is the beginning, not the end. Budget for iterations based on user feedback.

Conclusion

The best freelance developer for your startup is not necessarily the cheapest or the one with the most impressive resume. It is the one who understands your business, communicates clearly, has built similar products before, and structures the engagement for mutual success. Use this checklist during your evaluation, and you will dramatically increase your chances of a successful collaboration.

I work with startups to build MVPs and scale products using Python, Django, and AI. If you are looking for a technical partner for your project, check out my services or get in touch for a free consultation.

Originally published on kirweb.site. I build AI chatbots, SaaS platforms, and automation for businesses. Free consultation.

AI Automation for Small Business: 10 Ways to Save Time and Money in 2026

Kirill Strelnikov — Fri, 27 Feb 2026 05:31:39 +0000

AI Automation for Small Business: 10 Ways to Save Time and Money in 2026

AI is no longer a luxury for enterprises with million-dollar budgets. In 2026, small businesses with 5–50 employees can automate significant parts of their operations using AI tools and custom solutions — often for less than €1,000. The key is knowing which tasks to automate first and choosing the right approach for each.

1. Customer Support Chatbot

What it does: An AI chatbot on your website or WhatsApp handles routine customer questions 24/7 — business hours, pricing, product details, order status, return policies. It escalates complex issues to human agents with full context.

Expected savings: 40–70% reduction in support tickets. For a business handling 50 inquiries per day, that saves 2–3 hours of human time daily.

Cost: €800–3,000 for a custom chatbot. No-code platforms like Tidio or Intercom start at €30–100/month but lack depth.

Best for: E-commerce, SaaS, service businesses, clinics, restaurants.

2. Email Triage and Auto-Response

What it does: AI reads incoming emails, categorizes them (sales inquiry, support request, spam, partnership), drafts responses for routine messages, and routes important emails to the right team member.

Expected savings: 30–60 minutes per day for anyone who processes high email volume.

Cost: €400–1,500 for a custom solution using OpenAI API + email integration. Or use built-in AI features in Gmail/Outlook (limited but free).

Best for: Professional services, agencies, any business receiving 50+ emails daily.

3. Lead Qualification and Scoring

What it does: AI analyzes incoming leads based on criteria you define (company size, budget, industry, urgency) and assigns a score. High-scoring leads get immediate attention; low-scoring leads enter a nurture sequence.

Expected savings: Sales teams spend 30–50% less time on unqualified leads. Conversion rates typically increase by 20–35%.

Cost: €500–2,000 as part of a CRM automation setup.

Best for: B2B companies, agencies, consultants, SaaS businesses.

4. Invoice Processing and Bookkeeping

What it does: AI extracts data from invoices (vendor, amount, date, line items), categorizes expenses, and enters them into your accounting software. It can also flag anomalies (duplicate invoices, unusual amounts).

Expected savings: 2–5 hours per week for businesses processing 50+ invoices per month.

Cost: €500–1,500 for a custom extraction pipeline. Tools like Dext or AutoEntry charge €20–50/month.

Best for: Any business with regular invoice processing.

5. Social Media Content Generation

What it does: AI generates social media posts, captions, and hashtags based on your brand voice and content calendar. You review and approve before publishing.

Expected savings: 3–5 hours per week on content creation.

Cost: ChatGPT Plus at €20/month handles this for most businesses. Custom solutions with brand voice training cost €500–1,500.

Best for: Any business with active social media presence.

6. Appointment Scheduling with AI

What it does: An AI assistant handles appointment booking via WhatsApp, website chat, or email. It checks availability, suggests times, sends confirmations and reminders, handles rescheduling.

Expected savings: 1–2 hours per day for businesses with heavy booking volume. No-show rates drop 30–50% with automated reminders.

Cost: €500–2,000 for a custom bot integrated with your calendar. Tools like Cal.com (free) handle basic scheduling without AI.

Best for: Clinics, salons, consultants, agencies, fitness studios.

7. Document Generation

What it does: AI generates proposals, contracts, reports, and other documents from templates and data. A sales rep fills in key details; AI produces a polished, personalized document in seconds.

Expected savings: 1–3 hours per document. For a team creating 10 proposals per week, that is 10–30 hours saved.

Cost: €400–1,200 for a custom template-based generator. PandaDoc and Proposify offer this as SaaS at €30–80/month.

Best for: Agencies, consultants, law firms, real estate.

8. Inventory and Demand Forecasting

What it does: AI analyzes historical sales data, seasonality, and market trends to predict demand. It suggests optimal stock levels and alerts you when to reorder.

Expected savings: 15–30% reduction in overstock costs. Fewer stockouts mean fewer lost sales.

Cost: €1,000–3,000 for a custom forecasting model. Some ERP systems include basic forecasting features.

Best for: Retail, e-commerce, food and beverage, manufacturing.

9. Recruitment Screening

What it does: AI screens resumes against job requirements, ranks candidates, and generates shortlists. It can also draft personalized rejection emails and schedule interviews with top candidates.

Expected savings: 5–10 hours per hire on initial screening. Faster time-to-hire means less productivity lost from unfilled positions.

Cost: €500–1,500 for a custom screening tool. SaaS options like Greenhouse AI features cost €100–500/month.

Best for: Any business hiring regularly (3+ positions per quarter).

10. Data Entry and Migration

What it does: AI extracts data from various sources (PDFs, spreadsheets, emails, images), normalizes it, and enters it into your systems. Particularly powerful for migrating data between tools or consolidating information from multiple sources.

Expected savings: 80–95% reduction in manual data entry time.

Cost: €400–2,000 depending on data complexity and volume.

Best for: Any business dealing with manual data entry or system migrations.

Where to Start: The AI Automation Priority Matrix

Do not try to automate everything at once. Use this framework:

High volume + low complexity = automate first. Customer FAQ responses, email triage, data entry. These give the fastest ROI.
High volume + high complexity = automate with human oversight. Lead qualification, document generation. AI does 80% of the work, human reviews.
Low volume + low complexity = automate later or not at all. If something takes 10 minutes per week, the automation cost may not be justified.
Low volume + high complexity = keep human for now. Strategic decisions, complex negotiations, creative direction.

Real Costs vs. Real Savings

For a typical small business implementing their first three AI automations (customer support chatbot + email triage + lead qualification):

Total implementation cost: €1,500–4,000
Monthly running cost: €50–200 (AI API calls + hosting)
Monthly time saved: 40–80 hours
Monthly value of saved time: €800–2,000 (at €20–25/hour)
Payback period: 2–4 months

Getting Started

Pick one high-impact, low-complexity automation from this list and implement it. Measure the results over 30 days. Then add the next one. Building incrementally is cheaper and less risky than trying to automate everything at once.

I specialize in AI automation and chatbot development for small and mid-size businesses. If you want help identifying the best automation opportunities for your business, book a free consultation.

Originally published on kirweb.site. I build AI chatbots, SaaS platforms, and automation for businesses. Free consultation.

WhatsApp Chatbot for Business: Cost, Features, and How to Get Started

Kirill Strelnikov — Fri, 27 Feb 2026 05:30:35 +0000

WhatsApp Chatbot for Business: Cost, Features, and How to Get Started

WhatsApp has over 2 billion active users. For businesses, especially in Europe, Latin America, and Asia, it is often the primary channel customers use to ask questions, place orders, and request support. A WhatsApp chatbot automates these conversations, handling routine inquiries 24/7 while routing complex cases to human agents.

In this guide I explain what a WhatsApp chatbot can do, how much it costs to build one, and the technical requirements you need to know before starting.

What Can a WhatsApp Chatbot Do?

Customer Support Automation

The most common use case. A chatbot handles FAQs (business hours, shipping policies, return processes, pricing), provides order status updates, and collects information before handing off to a human agent when needed. Businesses typically automate 40–70% of incoming messages this way.

Sales and Lead Qualification

A chatbot can ask qualifying questions (budget, timeline, requirements), present product catalogs, send quotes, and schedule appointments — all within the WhatsApp conversation. This works especially well for service businesses, real estate, and B2B companies where the sales cycle starts with an inquiry.

Order Management

For e-commerce and food delivery, chatbots can take orders, process payments (via payment links or integrated gateways), send order confirmations, and provide delivery tracking. In markets where WhatsApp is dominant, this converts better than a website checkout because customers never leave their preferred app.

Appointment Booking

Clinics, salons, consultants, and service providers use WhatsApp chatbots to manage bookings. The bot shows available slots, confirms appointments, sends reminders, and handles rescheduling — reducing no-shows by 30–50%.

AI-Powered Conversations

Modern chatbots use large language models (GPT-4, Claude) to have natural, context-aware conversations. Instead of rigid menu-based flows, the bot understands free-text messages and responds intelligently. It can reference your product catalog, knowledge base, or FAQ documentation to give accurate answers in any language your customers speak.

How Much Does a WhatsApp Chatbot Cost?

Development Costs

| Tier | Price Range | What You Get

| Basic | €800–1,500 | FAQ automation, keyword-based responses, single-language, basic analytics, up to 20 conversation flows

| Advanced | €1,500–3,500 | AI-powered responses (GPT-4/Claude), multi-language, CRM integration, lead capture, conversation memory, handoff to human agents

| Enterprise | €3,500+ | Custom AI training on your data, multi-agent system, payment processing, advanced analytics dashboard, API integrations, multi-number support

Ongoing Costs

WhatsApp Business API: Meta charges per conversation. Business-initiated messages cost €0.05–0.15 depending on the country. User-initiated service conversations are free for the first 1,000 per month.
AI API costs: If using GPT-4 or Claude, expect €0.01–0.05 per conversation depending on message length and model choice. For most businesses, this is €50–200/month.
Hosting: A basic server costs €10–50/month. Higher traffic may need €50–200/month.
BSP fees: Business Solution Providers like Twilio, 360dialog, or WATI charge €50–200/month for API access and additional features.

Technical Requirements: WhatsApp Business API

WhatsApp Business App vs. API

The free WhatsApp Business App works for small businesses with low message volume. But for chatbot automation, you need the WhatsApp Business API. The key differences:

Business App: Free, manual replies, limited automation (quick replies, greeting messages), single device, no API access.
Business API: Programmable, full automation, webhooks, multi-agent support, analytics, message templates, CRM integration. Requires a Business Solution Provider (BSP) or direct access through Meta.

Getting API Access

You can access the WhatsApp Business API through:

Meta Cloud API (direct): Free to set up through Meta for Developers. You get a test number immediately and can go to production after business verification. This is the most cost-effective option.
BSP (Twilio, 360dialog, WATI, etc.): Easier setup, managed infrastructure, additional features like analytics dashboards and template management. Monthly fees apply.

Message Templates

WhatsApp requires pre-approved message templates for business-initiated conversations. These templates must be submitted to Meta for review and typically get approved within 24 hours. Your chatbot can reply freely to user-initiated messages within a 24-hour window without templates.

Building a WhatsApp Chatbot: Architecture

Typical Tech Stack

Backend: Python (Django/Flask) or Node.js
AI: OpenAI GPT-4o, Anthropic Claude, or open-source models
WhatsApp API: Meta Cloud API or BSP SDK
Database: PostgreSQL for conversation history and user data
Queue: Redis + Celery for async message processing
Hosting: VPS, AWS, or DigitalOcean

How It Works

Customer sends a message on WhatsApp
WhatsApp forwards it to your server via webhook
Your backend processes the message (NLP, AI, business logic)
The response is sent back via WhatsApp API
Conversation is logged in your database/CRM

Choosing Between a No-Code Platform and Custom Development

No-Code Platforms (ManyChat, Chatfuel, WATI)

Good for simple, template-based flows. You can set up a basic FAQ bot in a few hours. Limitations: rigid conversation flows, limited AI capabilities, vendor lock-in, monthly subscription costs that scale with message volume.

Custom Development

Better for businesses that need AI-powered conversations, complex integrations (CRM, ERP, payment systems), or custom business logic. Higher upfront cost but lower per-message cost and full flexibility. You own the code and can modify anything.

For most businesses doing under 500 conversations per month with simple FAQ needs, a no-code platform works fine. For anything more sophisticated — AI conversations, lead qualification, order processing — custom development pays for itself within months through better conversion rates and lower per-interaction costs.

ROI: When Does a WhatsApp Chatbot Pay for Itself?

Consider a service business that receives 50 WhatsApp inquiries per day. A human agent handles each inquiry in 5 minutes on average. That is roughly 4 hours of work per day, or about €2,000/month in labor costs for a dedicated support agent.

A chatbot that handles 60% of inquiries automatically saves €1,200/month. A custom chatbot costing €2,000 to build pays for itself in under two months. Adding lead qualification and sales automation increases revenue on top of the cost savings.

Getting Started

If you are considering a WhatsApp chatbot for your business, here is how to start:

Define your use case: Support automation? Sales? Bookings? Orders?
Map your conversation flows: What questions do customers ask? What information do you need?
Choose your approach: No-code platform for simple flows, custom development for AI and integrations.
Get WhatsApp API access: Apply through Meta for Developers or sign up with a BSP.
Build and test: Start with a few core flows, test with real customers, iterate.

I specialize in building custom WhatsApp chatbots with AI capabilities for businesses across Europe. If you want to discuss your use case, reach out for a free consultation.

Originally published on kirweb.site. I build AI chatbots, SaaS platforms, and automation for businesses. Free consultation.

How to Hire a Freelance Developer in Barcelona: Complete Guide for 2026

Kirill Strelnikov — Fri, 27 Feb 2026 05:30:34 +0000

How to Hire a Freelance Developer in Barcelona: Complete Guide for 2026

Barcelona has become one of Europe's top tech hubs, home to thousands of skilled freelance developers. Whether you need a web application, a mobile app backend, or an AI-powered chatbot, hiring a freelance developer in Barcelona gives you access to senior talent at rates significantly lower than London, Paris, or San Francisco.

In this guide I cover everything you need to know: typical rates, where to find developers, how to evaluate candidates, and how to structure a successful engagement.

Why Barcelona for Freelance Development?

Strong Tech Ecosystem

Barcelona hosts Mobile World Congress, Smart City Expo, and dozens of tech meetups every month. The city has a thriving startup scene with over 2,000 active startups and a growing pool of senior developers who chose freelancing over corporate positions. Many speak three or more languages — English, Spanish, and Catalan at minimum — making communication easy for international clients.

Competitive Rates

Freelance developer rates in Barcelona typically range from €40 to €100 per hour depending on experience and specialization. For comparison, equivalent talent in London charges €80–150/hour, and in San Francisco $120–200/hour. This means you can get the same quality of work for 40–60% less.

EU Time Zone Advantage

CET/CEST time zone overlaps well with both European and American East Coast business hours. For European companies, same-timezone collaboration means real-time communication during the workday. For US clients, the overlap covers the morning hours, which is usually enough for daily syncs.

Typical Rates for Barcelona Freelance Developers in 2026

| Specialization | Junior (1-3 years) | Mid (3-5 years) | Senior (5+ years)

| Python/Django | €35–50/hr | €50–75/hr | €75–100/hr

| JavaScript/React | €35–50/hr | €50–80/hr | €80–120/hr

| AI/ML Engineer | €45–60/hr | €60–90/hr | €90–130/hr

| Mobile (iOS/Android) | €40–55/hr | €55–80/hr | €80–110/hr

| DevOps/Cloud | €40–55/hr | €55–85/hr | €85–120/hr

For fixed-price projects, expect the following ranges:

Simple website or landing page: €500–2,000
Web application with backend: €2,000–8,000
SaaS MVP: €3,000–15,000
AI chatbot: €800–3,000
Telegram/WhatsApp bot: €500–2,500

Where to Find Freelance Developers in Barcelona

1. Specialized Portfolios and Personal Websites

The best freelancers maintain their own websites with case studies, pricing, and contact forms. Search for specific skills plus "Barcelona" or "freelance" — for example, "Django developer Barcelona". Developers who invest in their web presence tend to be more professional and reliable.

2. LinkedIn

Filter by location (Barcelona Metropolitan Area), set the headline filter to "freelance developer" or the specific technology you need. Look for profiles with recommendations from previous clients, not just colleagues.

3. Freelance Platforms

Upwork, Toptal, and Malt (popular in Spain) all have Barcelona-based developers. Toptal pre-screens candidates, so you pay a premium but save vetting time. Malt is particularly strong in Spain and France. Upwork gives you the widest selection but requires more due diligence.

4. Tech Meetups and Communities

Barcelona has active communities: Python Barcelona, Barcelona.js, AI/ML Barcelona, and many more. Attending a meetup (or joining their Slack/Discord) lets you meet developers in person and gauge their expertise from their talks and contributions.

How to Evaluate a Freelance Developer

Check Their Portfolio

Look for projects similar to yours. If you need a SaaS platform, a developer who has built three SaaS products will deliver faster and avoid common pitfalls. Ask for specific metrics: How many users does the app serve? What was the uptime? Did they handle the DevOps too?

Read Case Studies, Not Just Testimonials

Testimonials are easy to fabricate. Detailed case studies with specific challenges, solutions, and results are much harder to fake and much more informative. A developer who writes about their process shows they think methodically.

Technical Assessment

For a backend developer, ask about their approach to database design, authentication, error handling, and deployment. You do not need to give them a coding test — a 30-minute technical conversation is enough to gauge their depth. Ask about trade-offs they have made in previous projects.

Communication Skills

A freelancer who communicates clearly, sets expectations, and provides regular updates is worth more than a slightly better coder who disappears for days. During initial conversations, notice how quickly they respond, how clearly they explain concepts, and whether they ask clarifying questions about your project.

Structuring a Successful Engagement

Fixed Price vs. Hourly

For well-defined projects with clear requirements, fixed price works well — you know the total cost upfront. For exploratory work, ongoing maintenance, or projects where requirements may change, hourly billing gives you flexibility. Many freelancers offer both and can advise which model fits your situation.

Milestones and Deliverables

Break the project into milestones with specific deliverables. For example: Week 1 — database design and API skeleton. Week 2 — core features. Week 3 — integrations and testing. Each milestone should produce something you can review and test, so problems surface early.

Communication Cadence

Agree on a communication schedule upfront. A daily async update (even just a few sentences) plus one weekly video call works well for most projects. Use a shared project management tool (Trello, Linear, or even a shared document) to track progress.

Red Flags to Watch For

No portfolio or case studies: Every experienced developer has something to show.
Vague estimates: "It depends" is not a useful answer. A good developer can give you a range with assumptions stated.
No questions about your project: If they immediately quote a price without understanding your requirements, they are guessing.
Resistance to milestones: A professional welcomes structured deliverables because it protects both parties.
Too cheap: If someone quotes 50% below market rate, they will either deliver poor quality or disappear mid-project.

Conclusion

Barcelona offers an excellent pool of freelance developers at competitive European rates. The key to a successful hire is doing your homework: check portfolios, read case studies, have a technical conversation, and structure the engagement with clear milestones. Whether you need a Django developer, an AI chatbot specialist, or a backend architect, the city has talent to match your needs.

If you are looking for a freelance Python/Django developer in Barcelona with experience in AI, SaaS, and automation, feel free to get in touch for a free consultation.

Originally published on kirweb.site. I build AI chatbots, SaaS platforms, and automation for businesses. Free consultation.