DEV Community

Daniel Oettel
Daniel Oettel

Posted on

How I Automated My Freelance Business with Python (Step-by-Step)

#python #automation #freelancing #beginners

How I Automated My Freelance Business with Python (Step-by-Step)

As a freelancer, my primary concern is always to minimize the time spent on administrative tasks so I can focus on what I do best – delivering high-quality work for my clients. However, managing client communications, project timelines, and invoices manually can be tedious and time-consuming. That's why I decided to automate my freelance business using Python. Today, I'll walk you through the exact steps I took, and you can see for yourself how automated my business is now.

Understanding the Problem

When I first started my freelancing career, I used to manually keep track of client deadlines, track my time spent on projects, and manage invoices. This approach had some major drawbacks:

  • Lost productivity: I spent a significant portion of my week on admin tasks, which could have been better spent working on projects or finding new clients.
  • Error-prone: Manual tracking and invoicing can lead to errors, which can result in delayed payments or unhappy clients.
  • Scale limitations: As my business grew, it became increasingly difficult to manage everything manually without sacrificing productivity or compromising accuracy.

Planning the Automation Journey

Before jumping into Python programming, I identified the specific tasks I wanted to automate:

  • Client onboarding: Automate the process of sending new client welcome emails and contract proposals.
  • Project tracking: Create a system to track project deadlines and client communications.
  • Time tracking: Develop a tool to record time spent on projects and generate invoices automatically.
  • Invoice management: Design a process for automatically generating invoices based on project completion.

Setting Up the Automation Framework

To build my automation workflow, I opted for a simple Python framework using Flask for routing and SQLite for database management. I also used the PyQt library for building the GUI application. Here's a high-level overview of my setup:

.
|__ automation
|    |__ app.py (Flask app)
|    |__ models.py ( SQLAlchemy ORM)
|    |__ views.py (Routing and API endpoints)
|    |__ forms.py (Pythonic form data handling)
|    |__ db.py (SQLite database connector)
|    |__ gui.py (PyQt GUI application)
Enter fullscreen mode Exit fullscreen mode

Implementing Client Onboarding Automation

To automate client onboarding, I created a Python script that sends an email to new clients with a welcome message and a link to a proposal contract:

import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

# Server settings
SMTP_SERVER = 'smtp.gmail.com'
SMTP_PORT = 587
FROM_EMAIL = 'your-email@gmail.com'
PASSWORD = 'your-password'

# Client data and template
NEW_CLIENT_EMAIL = 'new-client-email@example.com'
CLIENT_NAME = 'John Doe'
TEMPLATE_FILE = 'welcome_email_template.txt'

# Send welcome email
def send_welcome_email(to_email, name):
    msg = MIMEMultipart()
    msg['From'] = FROM_EMAIL
    msg['To'] = to_email
    msg['Subject'] = 'Welcome to Our Team'

    with open(TEMPLATE_FILE, 'r') as file:
        template = file.read()
        template = template.replace('{name}', name)

    msg.attach(MIMEText(template, 'plain'))
    server = smtplib.SMTP(SMTP_SERVER, SMTP_PORT)
    server.starttls()
    server.login(FROM_EMAIL, PASSWORD)
    server.sendmail(FROM_EMAIL, to_email, msg.as_string())
    server.quit()

# Example usage
send_welcome_email(NEW_CLIENT_EMAIL, CLIENT_NAME)
Enter fullscreen mode Exit fullscreen mode

Automating Project Tracking and Time Recording

To track project deadlines and client communications, I created a GUI application using PyQt. The application allows users to add new projects, set deadlines, and record time spent on tasks:

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QFormLayout, QLineEdit, QLabel, QPushButton, QTableWidget, QTableWidgetItem

class ProjectTracker(QWidget):
    def __init__(self):
        super().__init__()

        self.project_table = QTableWidget()
        self.project_form = QFormLayout()

        self.new_project_button = QPushButton('New Project')
        self.new_project_button.clicked.connect(self.new_project)

        self.project_form.addRow(QLabel('Project Name:'), QLineEdit())
        self.project_form.addRow(QLabel('Deadline:'), QLineEdit())

        self.project_layout = QVBoxLayout()
        self.project_layout.addLayout(self.project_form)
        self.project_layout.addWidget(self.project_table)
        self.project_layout.addWidget(self.new_project_button)

        self.setLayout(self.project_layout)

    def new_project(self):
        # Create new project entry in database
        pass

if __name__ == '__main__':
    app = QApplication(sys.argv)
    project_tracker = ProjectTracker()
    project_tracker.resize(800, 600)
    project_tracker.show()
    sys.exit(app.exec_())
Enter fullscreen mode Exit fullscreen mode

Creating Automated Invoices

For automated invoice generation, I integrated a payment gateway using Stripe. The application generates an invoice for each completed project and sends it to the client via email:

import stripe
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

# Stripe settings
STRIPE_SECRET_KEY = 'your-stripe-secret-key'
STRIPE_PUBLIC_KEY = 'your-stripe-public-key'

# Project data and template
PROJECT_ID = 1
CLIENT_EMAIL = 'client-email@example.com'
TEMPLATE_FILE = 'invoice_template.txt'

# Generate invoice
def generate_invoice(project_id, client_email):
    invoice = stripe.Invoice.create(
        client_email=client_email,
        amount=1000,
        currency='usd',
        statement_descriptor='My Business'
    )

    # Send invoice via email
    msg = MIMEMultipart()
    msg['From'] = 'your-email@gmail.com'
    msg['To'] = client_email
    msg['Subject'] = 'Invoice for Project {}'.format(project_id)

    with open(TEMPLATE_FILE, 'r') as file:
        template = file.read()
        template = template.replace('{amount}', str(invoice.amount))
        template = template.replace('{currency}', invoice.currency)

    msg.attach(MIMEText(template, 'plain'))
    server = smtplib.SMTP('smtp.gmail.com', 587)
    server.starttls()
    server.login('your-email@gmail.com', 'your-password')
    server.sendmail('your-email@gmail.com', client_email, msg.as_string())
    server.quit()

# Example usage
generate_invoice(PROJECT_ID, CLIENT_EMAIL)
Enter fullscreen mode Exit fullscreen mode

Conclusion

Automating my freelance business using Python transformed the way I work. The freedom to focus on high-leverage activities rather than admin tasks has greatly increased my productivity and job satisfaction. If you're looking to automate your own freelance business, I encourage you to take the step-by-step approach outlined above and adjust it to fit your unique needs.

Found this useful? Check out my 'Freelancing Mastery' course on Gumroad, where I dive deeper into freelance management, marketing, and automation strategies.

Top comments (0)