DEV Community: Lucas Gragg

Building an invoice generator with ReportLab

Lucas Gragg — Thu, 09 Apr 2026 19:31:39 +0000

When I started freelancing, I quickly realized that generating professional-looking invoices was a chore. I'd spend hours tweaking Microsoft Word templates, making sure the numbers added up and the layout looked decent. It was a tedious process, and I knew there had to be a better way. That's when I discovered ReportLab, a Python library that allows you to generate PDF documents programmatically. With ReportLab, I was able to automate the invoice generation process, saving myself a significant amount of time and effort.

Getting Started with ReportLab

To get started with ReportLab, you'll need to install the library using pip. Once installed, you can begin generating PDF documents using the SimpleDocTemplate class. This class provides a simple way to create PDFs with basic layout and styling. For example, you can use the following code to generate a basic PDF document:

from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import letter
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.lib.units import inch
from reportlab.platypus import SimpleDocTemplate, Paragraph

# Create a new PDF document
doc = SimpleDocTemplate("example.pdf", pagesize=letter)

# Add a paragraph to the document
styles = getSampleStyleSheet()
story = [Paragraph("This is a sample paragraph.", styles["Normal"])]

# Build the document
doc.build(story)

This code generates a basic PDF document with a single paragraph of text.

Creating an Invoice Template

To create an invoice template, you'll need to define a layout that includes fields for the invoice number, date, client information, and line items. You can use the Table class from ReportLab to create a table for the line items. Here's an example of how you might define an invoice template:

from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import letter
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.lib.units import inch
from reportlab.platypus import SimpleDocTemplate, Paragraph, Table, TableStyle

# Define the invoice template
class InvoiceTemplate:
    def __init__(self, invoice_number, date, client_name, line_items):
        self.invoice_number = invoice_number
        self.date = date
        self.client_name = client_name
        self.line_items = line_items

    def generate_pdf(self):
        # Create a new PDF document
        doc = SimpleDocTemplate("invoice.pdf", pagesize=letter)

        # Add the invoice header
        story = [Paragraph(f"Invoice Number: {self.invoice_number}", getSampleStyleSheet()["Heading1"])]
        story.append(Paragraph(f"Date: {self.date}", getSampleStyleSheet()["Normal"]))
        story.append(Paragraph(f"Client: {self.client_name}", getSampleStyleSheet()["Normal"]))

        # Add the line items table
        table_data = [["Item", "Quantity", "Price"]]
        for item in self.line_items:
            table_data.append([item["name"], item["quantity"], item["price"]])
        table = Table(table_data)
        table_style = TableStyle([
            ("GRID", (0, 0), (-1, -1), 0.5, (0, 0, 0)),
            ("FONTNAME", (0, 0), (-1, -1), "Helvetica"),
            ("FONTSIZE", (0, 0), (-1, -1), 12),
        ])
        table.setStyle(table_style)
        story.append(table)

        # Build the document
        doc.build(story)

This code defines a basic invoice template with fields for the invoice number, date, client information, and line items.

Putting it all Together

I actually packaged this into a tool called Invoice Generator if you want the full working version, which you can find at https://lukegraggster.gumroad.com/l/invoice-generator?utm_source=devto&utm_medium=blog&utm_campaign=traffic_bot. This tool allows you to generate professional-looking invoices with customizable templates, automatic calculations, and client management. It's been a huge time-saver for me, and I think it could be really helpful for other freelancers and small businesses as well. With the Invoice Generator, you can create professional PDF invoices in seconds, and it's only $29. I'm really proud of how it's turned out, and I think it's a great solution for anyone who needs to generate invoices on a regular basis.

PumpPortal API tutorial: sniping new launches

Lucas Gragg — Thu, 09 Apr 2026 13:31:29 +0000

I've been working on pump.fun token sniper bot (solana) for a while and wanted to share what I learned.

The problem

Snipe new token launches on Pump.fun. WebSocket-powered detection, instant buy execution, configurable scoring (dev buy size, meme keywords), take-profit/stop-loss, and trailing stops.

What I built

Here are the main features I ended up shipping:

Pump.fun WebSocket detection
Sub-second buy execution
Token scoring algorithm
TP/SL/trailing stop
Max hold timer
Dashboard with live token feed

Code sample

# Basic structure
class Bot:
    def __init__(self, config):
        self.config = config

    def run(self):
        while True:
            self.scan()
            self.execute()

If you want the full working version with all the battle-tested edge cases
handled, I packaged it here: Pump.fun Token Sniper Bot (Solana)

Happy to answer questions about the architecture in the comments.

Async API requests: asyncio + httpx tutorial

Lucas Gragg — Thu, 09 Apr 2026 07:31:22 +0000

I've been working on api automation framework for a while and wanted to share what I learned.

The problem

Connect and automate any REST API with this plug-and-play Python framework. Schedule tasks, chain API calls, handle authentication, and build complex workflows without writing boilerplate code.

What I built

Here are the main features I ended up shipping:

Universal REST API client with OAuth and API key auth
Workflow builder for chaining multi-step API calls
Built-in scheduler with cron-style timing
Retry logic, rate limiting, and error handling
Logging dashboard and webhook notifications

Code sample

# Basic structure
class Bot:
    def __init__(self, config):
        self.config = config

    def run(self):
        while True:
            self.scan()
            self.execute()

If you want the full working version with all the battle-tested edge cases
handled, I packaged it here: API Automation Framework

Happy to answer questions about the architecture in the comments.

Telegram price alerts in 50 lines of Python

Lucas Gragg — Thu, 09 Apr 2026 01:31:12 +0000

I recently found myself needing to set up a system to notify me when the price of a particular cryptocurrency reached a certain threshold. I'm sure I'm not the only one who's ever sat watching the market, waiting for a specific price point to be hit. It's tedious and unnecessary, especially when you can automate the process. I decided to write a simple script to handle this for me, and it turned out to be a relatively straightforward task.

Setting up the basics

To start, I needed to choose a library to handle the Telegram notifications. I opted for python-telegram-bot, as it seems to be one of the most popular and well-maintained options. I also needed a way to get the current price of the cryptocurrency I was interested in. For this, I used the CoinGecko API, which provides a simple and free way to get current and historical price data for a wide range of cryptocurrencies.

The code

Here's a simplified version of the script I came up with:

import requests
import time
from telegram.ext import Updater, CommandHandler, MessageHandler

# Set up Telegram bot
TOKEN = 'YOUR_TELEGRAM_BOT_TOKEN'
updater = Updater(TOKEN, use_context=True)

# Set up CoinGecko API
COINGECKO_API_URL = 'https://api.coingecko.com/api/v3/simple/price'
COIN_ID = 'bitcoin'
CURRENCY = 'usd'

def get_current_price():
    params = {'ids': COIN_ID, 'vs_currencies': CURRENCY}
    response = requests.get(COINGECKO_API_URL, params=params)
    data = response.json()
    return data[COIN_ID][CURRENCY]

def send_notification(price):
    updater.dispatcher.bot.send_message(chat_id='YOUR_CHAT_ID', text=f'Current price: {price}')

def main():
    target_price = 50000
    while True:
        current_price = get_current_price()
        if current_price >= target_price:
            send_notification(current_price)
        time.sleep(60)

if __name__ == '__main__':
    main()

This script will continuously check the current price of the specified cryptocurrency and send a Telegram notification when it reaches the target price.

Expanding the functionality

As I was working on this script, I realized that I wanted to be able to set up multiple alerts for different cryptocurrencies and price points. I also wanted to be able to receive notifications via email or Discord, in addition to Telegram. This started to get a bit more complicated, and I ended up with a much larger script than I had initially anticipated. I actually packaged this into a tool called Crypto Price Alert Bot if you want the full working version, which you can find at https://lukegraggster.gumroad.com/l/crypto-price-alert?utm_source=devto&utm_medium=blog&utm_campaign=traffic_bot. It's been really useful for me, and I think it could be for you too.

My 8-bot autonomous trading fleet (open source components)

Lucas Gragg — Wed, 08 Apr 2026 19:31:01 +0000

I've been experimenting with autonomous trading bots for a while now, and I recently decided to take it to the next level by building an 8-bot fleet. The idea was to have each bot focus on a specific market or strategy, and then use a master script to manage and monitor them all. I started by setting up each bot as a separate Python process, using a combination of libraries like CCXT and Pandas to handle the trading logic.

Building the Bots

The first step was to define the trading logic for each bot. I used a simple moving average crossover strategy for a few of them, while others were based on more complex indicators like the RSI and Bollinger Bands. I also experimented with different market data feeds, including WebSocket connections to various exchanges. Here's an example of how I implemented the moving average crossover strategy in one of the bots:

import ccxt
import pandas as pd

exchange = ccxt.binance({
    'apiKey': 'YOUR_API_KEY',
    'apiSecret': 'YOUR_API_SECRET',
})

def fetch_data(symbol, timeframe):
    bars = exchange.fetch_ohlcv(symbol, timeframe=timeframe)
    df = pd.DataFrame(bars, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
    return df

def calculate_ma(df, short_window, long_window):
    df['short_ma'] = df['close'].rolling(window=short_window).mean()
    df['long_ma'] = df['close'].rolling(window=long_window).mean()
    return df

def check_crossover(df):
    if df['short_ma'].iloc[-1] > df['long_ma'].iloc[-1] and df['short_ma'].iloc[-2] < df['long_ma'].iloc[-2]:
        return True
    elif df['short_ma'].iloc[-1] < df['long_ma'].iloc[-1] and df['short_ma'].iloc[-2] > df['long_ma'].iloc[-2]:
        return False
    else:
        return None

symbol = 'BTC/USDT'
timeframe = '1m'
short_window = 50
long_window = 200

df = fetch_data(symbol, timeframe)
df = calculate_ma(df, short_window, long_window)
crossover = check_crossover(df)

if crossover:
    print('Buy signal')
elif not crossover:
    print('Sell signal')

Managing the Fleet

Once I had all the bots up and running, I needed a way to manage and monitor them. I wrote a master script that would periodically check the status of each bot, restart any that had crashed, and send me notifications if anything went wrong. I also built a simple dashboard to display the performance of each bot, using a combination of metrics like profit/loss, drawdown, and Sharpe ratio.

Putting it all Together

I actually packaged this into a tool called Complete Trading Bot Suite if you want the full working version. It includes all the trading bots, a Telegram management agent, and a master dashboard to monitor everything from your phone. I've found it to be a huge time-saver, and it's allowed me to focus on refining my trading strategies rather than worrying about the underlying infrastructure. You can check it out at https://lukegraggster.gumroad.com/l/full-trading-suite?utm_source=devto&utm_medium=blog&utm_campaign=traffic_bot. I'm still actively developing and refining the suite, but it's already saved me a significant amount of time and hassle.

One bot, two platforms: Discord + Telegram

Lucas Gragg — Wed, 08 Apr 2026 13:30:49 +0000

I've been working on a project that involves creating a bot that can run on both Discord and Telegram. At first, I thought it would be a simple task, but I quickly realized that each platform has its own set of APIs and requirements. I had to create separate codebases for each platform, which led to a lot of duplicated code and maintenance issues. That's when I decided to create a unified bot framework that could handle both Discord and Telegram.

The Problem with Duplicate Code

When I started working on the bot, I created separate codebases for Discord and Telegram. This led to a lot of duplicated code, especially when it came to handling commands and user interactions. For example, I had to create separate functions for handling the /start command on Telegram and the !start command on Discord. This not only increased the maintenance time but also made it harder to add new features to the bot.

Creating a Unified Framework

To solve this problem, I decided to create a unified bot framework that could handle both Discord and Telegram. I started by identifying the common functionality between the two platforms, such as handling commands and user interactions. I then created a modular system that could handle these interactions in a platform-agnostic way. Here's an example of how I handled commands in the unified framework:

import discord
from discord.ext import commands
import telegram
from telegram.ext import CommandHandler

class Bot:
    def __init__(self):
        self.discord_bot = commands.Bot(command_prefix='!')
        self.telegram_bot = telegram.Bot(token='YOUR_TELEGRAM_TOKEN')

    def handle_command(self, command, args):
        # Handle the command in a platform-agnostic way
        if command == 'start':
            # Handle the start command
            pass
        elif command == 'help':
            # Handle the help command
            pass

    def discord_command_handler(self, ctx):
        # Handle Discord commands
        command = ctx.command.name
        args = ctx.args
        self.handle_command(command, args)

    def telegram_command_handler(self, update, context):
        # Handle Telegram commands
        command = update.message.text.split(' ')[0][1:]
        args = update.message.text.split(' ')[1:]
        self.handle_command(command, args)

Adding Webhook Support

Another important feature I needed to add to the bot was webhook support. This would allow me to integrate the bot with external services and receive notifications when certain events occurred. I added a webhook receiver to the bot that could handle incoming requests and trigger certain actions. Here's an example of how I implemented the webhook receiver:

import flask
from flask import request

class WebhookReceiver:
    def __init__(self, bot):
        self.bot = bot
        self.app = flask.Flask(__name__)

    def handle_webhook(self):
        # Handle incoming webhook requests
        if request.method == 'POST':
            # Trigger certain actions based on the incoming request
            pass
        else:
            # Handle other types of requests
            pass

    def run(self):
        # Run the webhook receiver
        self.app.run()

Putting it all Together

I actually packaged this into a tool called Discord & Telegram Bot if you want the full working version. It's a dual-platform bot framework that includes modular command handlers, admin controls, and webhook integrations. You can use it to deploy community bots, notification systems, or custom tools in minutes. I've made it available for $49 at https://lukegraggster.gumroad.com/l/discord-telegram-bot?utm_source=devto&utm_medium=blog&utm_campaign=traffic_bot. I'm still working on adding more features to the bot, but it's already saved me a lot of time and effort in maintaining my own bots.

Building a real-time Flask dashboard for your trading bot

Lucas Gragg — Wed, 08 Apr 2026 07:30:38 +0000

When I first started building my trading bot, I quickly realized that I needed a way to visualize its performance in real-time. I wanted to be able to see the bot's current trades, its profit and loss, and any errors that might be occurring. After some research, I decided to use Flask to build a simple web dashboard that would display this information. In this post, I'll walk through how I built the dashboard and some of the challenges I encountered along the way.

Designing the Dashboard

The first step in building the dashboard was to decide what information I wanted to display. I knew I wanted to show the bot's current trades, including the symbol, entry price, and current profit and loss. I also wanted to display any errors that might be occurring, such as connection issues with the exchange or problems with the bot's trading logic. I decided to use a simple table to display this information, with each row representing a single trade.

Building the Dashboard

To build the dashboard, I used Flask to create a simple web server that would display the trade information. I used the flask library to create the server, and the jinja2 library to render the HTML templates. I also used the ccxt library to connect to the exchange and retrieve the trade information. Here's an example of how I used these libraries to display the trade information:

from flask import Flask, render_template
import ccxt

app = Flask(__name__)

# Connect to the exchange
exchange = ccxt.binance({
    'apiKey': 'YOUR_API_KEY',
    'apiSecret': 'YOUR_API_SECRET',
})

# Define a function to retrieve the trade information
def get_trades():
    trades = exchange.fetch_trades('BTC/USDT')
    return trades

# Define a route for the dashboard
@app.route('/')
def dashboard():
    trades = get_trades()
    return render_template('dashboard.html', trades=trades)

if __name__ == '__main__':
    app.run()

This code creates a simple Flask server that connects to the Binance exchange and retrieves the trade information for the BTC/USDT symbol. It then renders an HTML template called dashboard.html and passes the trade information to the template.

Adding Real-time Updates

To add real-time updates to the dashboard, I used the flask-socketio library to create a WebSocket connection between the client and server. This allowed me to push updates from the server to the client in real-time, without the need for the client to constantly poll the server for updates. Here's an example of how I used this library to add real-time updates:

from flask_socketio import SocketIO, emit

# Create a SocketIO instance
socketio = SocketIO(app)

# Define a function to update the trade information
def update_trades():
    trades = get_trades()
    socketio.emit('update_trades', trades)

# Define a route for the dashboard
@app.route('/')
def dashboard():
    trades = get_trades()
    return render_template('dashboard.html', trades=trades)

# Define a SocketIO event to update the trade information
@socketio.on('connect')
def connect():
    update_trades()

# Run the SocketIO instance
if __name__ == '__main__':
    socketio.run(app)

This code creates a SocketIO instance and defines a function to update the trade information. It then defines a route for the dashboard and a SocketIO event to update the trade information when the client connects.

I actually packaged this into a tool called Crypto Exchange Trading Bot (Python) if you want the full working version, which includes a lot of other features like support for multiple exchanges, different trading strategies, and risk management tools. You can check it out at https://lukegraggster.gumroad.com/l/crypto-exchange-bot?utm_source=devto&utm_medium=blog&utm_campaign=traffic_bot. Overall, building a real-time Flask dashboard for my trading bot was a great way to visualize its performance and make adjustments on the fly.

Building a Hyperliquid perpetual futures bot from scratch

Lucas Gragg — Wed, 08 Apr 2026 01:30:26 +0000

Building a Hyperliquid perpetual futures bot from scratch has been a challenging yet rewarding experience for me. As a developer with a passion for trading and automation, I've always been fascinated by the concept of creating a bot that can trade perpetual futures contracts with high leverage. In this post, I'll share my experience and insights on building such a bot, including the technical difficulties I encountered and how I overcame them.

Designing the Bot Architecture

The first step in building the bot was to design its architecture. I decided to use a microservices approach, with separate modules for trading, risk management, and strategy execution. This allowed me to develop and test each module independently, making it easier to debug and maintain the code. I chose Python as the programming language, mainly due to its extensive libraries and frameworks for trading and automation.

Implementing Trading Logic

The trading logic was implemented using a combination of technical indicators and machine learning algorithms. I used the popular CCXT library to interact with the Hyperliquid DEX, which provided a unified API for trading and market data. The trading logic was implemented in a separate module, which made it easy to switch between different strategies and parameters. Here's an example of how I implemented a simple momentum-based strategy:

import ccxt
import pandas as pd

# Initialize the exchange and fetch market data
exchange = ccxt.hyperliquid({
    'apiKey': 'YOUR_API_KEY',
    'apiSecret': 'YOUR_API_SECRET',
})
markets = exchange.fetch_markets()

# Define the trading strategy
def momentum_strategy(symbol, timeframe):
    # Fetch historical data
    bars = exchange.fetch_ohlcv(symbol, timeframe=timeframe)
    df = pd.DataFrame(bars, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])

    # Calculate momentum indicators
    df['momentum'] = df['close'].rolling(window=20).mean()
    df['signal'] = df['momentum'].rolling(window=10).mean()

    # Generate trading signals
    df['signal'] = df['momentum'] > df['signal']

    return df

# Execute the trading strategy
symbol = 'BTC/USDT'
timeframe = '1m'
df = momentum_strategy(symbol, timeframe)
if df['signal'].iloc[-1]:
    # Send a buy order
    exchange.place_order(symbol, 'limit', 'buy', 100, 5000)
else:
    # Send a sell order
    exchange.place_order(symbol, 'limit', 'sell', 100, 5000)

Risk Management and Position Sizing

Risk management and position sizing were crucial components of the bot. I implemented a simple risk management system that adjusted the position size based on the account equity and the desired risk level. The bot also included a trailing stop-loss feature, which helped to limit losses and lock in profits.

Putting it all Together

After implementing the trading logic, risk management, and position sizing, I was able to put the bot together and test it in a live trading environment. The results were promising, with the bot generating consistent profits over a prolonged period. I actually packaged this into a tool called Hyperliquid Perpetual Futures Trading Bot if you want the full working version, which you can find at https://lukegraggster.gumroad.com/l/hyperliquid-perp-bot?utm_source=devto&utm_medium=blog&utm_campaign=traffic_bot. The bot supports long and short positions, up to 50x leverage, and includes three built-in strategies, making it a versatile tool for traders of all levels.

Natural language commands for your trading fleet

Lucas Gragg — Tue, 07 Apr 2026 19:30:18 +0000

I've been working on telegram trading bot manager & agent for a while and wanted to share what I learned.

The problem

Monitor and control all your trading bots from Telegram. Natural language commands, auto-restart on crash, performance tracking, and smart alerts. Works with any bot that exposes an HTTP API.

What I built

Here are the main features I ended up shipping:

Telegram command interface
Natural language understanding
Auto-restart offline bots
Auto-pause losing bots
Performance optimizer
Multi-bot monitoring

Code sample

# Basic structure
class Bot:
    def __init__(self, config):
        self.config = config

    def run(self):
        while True:
            self.scan()
            self.execute()

If you want the full working version with all the battle-tested edge cases
handled, I packaged it here: Telegram Trading Bot Manager & Agent

Happy to answer questions about the architecture in the comments.

LinkedIn scraping with Selenium: what still works

Lucas Gragg — Tue, 07 Apr 2026 13:28:25 +0000

I've been working on email lead generator for a while and wanted to share what I learned.

The problem

Automatically discover and collect verified business email addresses from any industry or niche. Perfect for sales teams, marketers, and freelancers who need a steady pipeline of qualified leads without manual research.

What I built

Here are the main features I ended up shipping:

Bulk email discovery from domains and websites
Email verification and bounce detection
Export to CSV, JSON, or CRM-ready formats
Rate limiting and proxy support for safe scraping
Configurable filters by role, domain, and industry

Code sample

# Basic structure
class Bot:
    def __init__(self, config):
        self.config = config

    def run(self):
        while True:
            self.scan()
            self.execute()

If you want the full working version with all the battle-tested edge cases
handled, I packaged it here: Email Lead Generator

Happy to answer questions about the architecture in the comments.

Kalshi bot: finding edge in prediction markets

Lucas Gragg — Tue, 07 Apr 2026 07:28:19 +0000

I've been working on kalshi/polymarket prediction market bot for a while and wanted to share what I learned.

The problem

Automated prediction market trading bot. Scans Kalshi and Polymarket for mispriced events, calculates edge, and executes trades automatically. Includes position tracking, P&L dashboard, and Telegram alerts.

What I built

Here are the main features I ended up shipping:

Kalshi API integration
Polymarket support
Edge detection algorithm
Auto-entry with configurable filters
Position management and exit logic
Web dashboard with live P&L

Code sample

# Basic structure
class Bot:
    def __init__(self, config):
        self.config = config

    def run(self):
        while True:
            self.scan()
            self.execute()

If you want the full working version with all the battle-tested edge cases
handled, I packaged it here: Kalshi/Polymarket Prediction Market Bot

Happy to answer questions about the architecture in the comments.

DEX sniper bot: how to get first-block fills

Lucas Gragg — Tue, 07 Apr 2026 01:28:14 +0000

I've been working on multi-chain dex trading bot (8 chains) for a while and wanted to share what I learned.

The problem

Trade on 8 blockchain networks from one bot. Supports Ethereum (Uniswap), Solana (Jupiter), BSC (PancakeSwap), Polygon (QuickSwap), Arbitrum (SushiSwap), Optimism (Velodrome), Avalanche (TraderJoe), and Cronos (VVS).

What I built

Here are the main features I ended up shipping:

8 blockchain networks
8 DEX integrations
Token sniping and trading
Gas optimization
Multi-wallet support
Web dashboard

Code sample

# Basic structure
class Bot:
    def __init__(self, config):
        self.config = config

    def run(self):
        while True:
            self.scan()
            self.execute()

If you want the full working version with all the battle-tested edge cases
handled, I packaged it here: Multi-Chain DEX Trading Bot (8 Chains)

Happy to answer questions about the architecture in the comments.