Full-Stack Business Automation Project Showcase

Python API Service

Flask-based REST API with lead processing

# app.py - Flask API Server
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
import joblib
import numpy as np

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://localhost/leads'
db = SQLAlchemy(app)

# Load pre-trained ML model for lead scoring
lead_scoring_model = joblib.load('models/lead_scorer.pkl')

class Lead(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    company_name = db.Column(db.String(200), nullable=False)
    contact_person = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(120), nullable=False)
    industry = db.Column(db.String(50))
    company_size = db.Column(db.String(20))
    budget = db.Column(db.String(20))
    score = db.Column(db.Integer, default=0)
    status = db.Column(db.String(20), default='new')
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

@app.route('/api/leads', methods=['POST'])
def create_lead():
    try:
        data = request.get_json()
        
        # Validate required fields
        required_fields = ['company_name', 'contact_person', 'email']
        for field in required_fields:
            if not data.get(field):
                return jsonify({'error': f'{field} is required'}), 400
        
        # Create new lead
        lead = Lead(
            company_name=data['company_name'],
            contact_person=data['contact_person'],
            email=data['email'],
            industry=data.get('industry'),
            company_size=data.get('company_size'),
            budget=data.get('budget')
        )
        
        # Calculate lead score using ML model
        features = extract_features(data)
        lead.score = int(lead_scoring_model.predict([features])[0])
        
        # Auto-assign status based on score
        if lead.score >= 80:
            lead.status = 'hot'
            send_priority_notification(lead)
        elif lead.score >= 60:
            lead.status = 'warm'
        else:
            lead.status = 'cold'
        
        db.session.add(lead)
        db.session.commit()
        
        return jsonify({
            'id': lead.id,
            'score': lead.score,
            'status': lead.status,
            'message': 'Lead created successfully'
        }), 201
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500

def extract_features(data):
    """Extract features for ML model"""
    # Industry scoring
    industry_scores = {
        'technology': 90, 'finance': 85, 'healthcare': 80,
        'manufacturing': 70, 'retail': 60, 'other': 50
    }
    
    # Company size scoring
    size_scores = {
        'enterprise': 100, 'large': 80, 'medium': 60,
        'small': 40, 'startup': 20
    }
    
    # Budget scoring
    budget_scores = {
        'over-500k': 100, '100k-500k': 80, '50k-100k': 60,
        '10k-50k': 40, 'under-10k': 20
    }
    
    features = [
        industry_scores.get(data.get('industry'), 50),
        size_scores.get(data.get('company_size'), 30),
        budget_scores.get(data.get('budget'), 30),
        len(data.get('description', '')) / 10,  # Description quality
        1 if '@' in data.get('email', '') else 0  # Email validity
    ]
    
    return np.array(features)

if __name__ == '__main__':
    with app.app_context():
        db.create_all()
    app.run(debug=True)

Database Schema

PostgreSQL tables and relationships

-- Database Schema Design
-- leads.sql

CREATE TABLE leads (
    id SERIAL PRIMARY KEY,
    company_name VARCHAR(200) NOT NULL,
    contact_person VARCHAR(100) NOT NULL,
    email VARCHAR(120) NOT NULL UNIQUE,
    phone VARCHAR(20),
    industry VARCHAR(50),
    company_size VARCHAR(20),
    budget VARCHAR(20),
    description TEXT,
    score INTEGER DEFAULT 0 CHECK (score >= 0 AND score <= 100),
    status VARCHAR(20) DEFAULT 'new' CHECK (status IN ('new', 'cold', 'warm', 'hot', 'converted', 'lost')),
    assigned_to INTEGER REFERENCES users(id),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    last_contacted TIMESTAMP,
    conversion_date TIMESTAMP
);

CREATE TABLE lead_activities (
    id SERIAL PRIMARY KEY,
    lead_id INTEGER REFERENCES leads(id) ON DELETE CASCADE,
    activity_type VARCHAR(50) NOT NULL,
    description TEXT,
    performed_by INTEGER REFERENCES users(id),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE lead_scoring_factors (
    id SERIAL PRIMARY KEY,
    lead_id INTEGER REFERENCES leads(id) ON DELETE CASCADE,
    factor_name VARCHAR(100) NOT NULL,
    factor_value DECIMAL(5,2),
    weight DECIMAL(3,2),
    contribution INTEGER,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE automation_workflows (
    id SERIAL PRIMARY KEY,
    name VARCHAR(200) NOT NULL,
    trigger_event VARCHAR(100) NOT NULL,
    conditions JSONB,
    actions JSONB,
    is_active BOOLEAN DEFAULT true,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    last_executed TIMESTAMP
);

-- Indexes for performance
CREATE INDEX idx_leads_score ON leads(score DESC);
CREATE INDEX idx_leads_status ON leads(status);
CREATE INDEX idx_leads_industry ON leads(industry);
CREATE INDEX idx_leads_created_at ON leads(created_at DESC);
CREATE INDEX idx_lead_activities_lead_id ON lead_activities(lead_id);
CREATE INDEX idx_lead_activities_type ON lead_activities(activity_type);

-- Triggers for automatic timestamp updates
CREATE OR REPLACE FUNCTION update_updated_at_column()
RETURNS TRIGGER AS $$
BEGIN
    NEW.updated_at = CURRENT_TIMESTAMP;
    RETURN NEW;
END;
$$ language 'plpgsql';

CREATE TRIGGER update_leads_updated_at 
    BEFORE UPDATE ON leads 
    FOR EACH ROW 
    EXECUTE FUNCTION update_updated_at_column();

-- Views for analytics
CREATE VIEW lead_summary AS
SELECT 
    DATE_TRUNC('day', created_at) as date,
    COUNT(*) as total_leads,
    AVG(score) as avg_score,
    COUNT(CASE WHEN status = 'hot' THEN 1 END) as hot_leads,
    COUNT(CASE WHEN status = 'warm' THEN 1 END) as warm_leads,
    COUNT(CASE WHEN status = 'cold' THEN 1 END) as cold_leads,
    COUNT(CASE WHEN status = 'converted' THEN 1 END) as converted_leads
FROM leads
GROUP BY DATE_TRUNC('day', created_at)
ORDER BY date DESC;