There are small things you can code yourself instead of paying for a SaaS

LiMa, light mode. 7 software licenses tracked, automatic days-remaining calculation. 100% local.

LiMa is a project I built two years ago. I know I'd do it differently today — PyQt6 instead of PyQt5, SQLAlchemy instead of raw sqlite3, keyring for SMTP credentials. I'll come back to that at the end.

But the point of this article isn't my tech debt. The point is that there are small things you can code yourself instead of paying for an annual subscription. LiMa is a good example.

The scenario that pushed me to build it: your IT director forwards you the annual quote for a "Software Asset Management" tool to track software license expiration dates. You open the PDF. Hundreds of dollars a month. You click on the feature sheet. The product, in essence: a SQL table with dates, a notification cron, a monthly recap email. That's it.

That's how LiMa (License Manager) was born. A PyQt5 desktop app running locally on the workstation of whoever handles the software inventory, plugged into a SQLite file. This article walks through the four technical bricks with the real code — not to convince you that SaaS is bad (sometimes it's the right call), but to show you that for this kind of need, paying is borderline laziness.

Brick 1 — SQLite + a "days remaining" calculation that updates itself

The table has two columns. Not three. Not ten. Two.

self.c.execute('''CREATE TABLE licences
                  (nom_logiciel TEXT, date_expiration TEXT)''')

Everything else is computed on the fly. The number of days remaining is not stored: it's derived in real time on every table refresh, because it's a temporal value that changes by itself. Storing it would just bake a stale-data bug into your database.

date_expiration = datetime.strptime(date_expiration_str, "%Y-%m-%d")
jours_restants = (date_expiration - datetime.now()).days
self.tableau_licences.setItem(row, 2, QTableWidgetItem(str(jours_restants)))

A QTimer replays this loop:

self.timer = QTimer(self)
self.timer.timeout.connect(self.actualiser_tableau)
self.timer.start(60_000)  # 1 min — dates don't change faster than that

Small confession: in the original code I had start(1000) (1 Hz). A leftover from my early days when I thought you had to "refresh often". 60 seconds is plenty, and it consumes way less.

The result: the table is alive. Rows turn red when a license is about to expire, with no manual reload.

Brick 2 — Native multi-tier notifications with plyer

Where the SaaS guys sell you "smart alerting", LiMa does this:

if jours_restants <= 30 and jours_restants > 14:
    notification.notify(
        title="License about to expire",
        message=f"License for {nom_logiciel} expires in less than 1 month.",
        app_name="LiMa",
        timeout=3,
    )
elif jours_restants <= 14 and jours_restants > 7:
    # …same idea, "less than 2 weeks"
elif jours_restants <= 7 and jours_restants > 3:
    # …same idea, "less than 1 week"
elif jours_restants <= 3 and jours_restants > 1:
    # …same idea, "less than 3 days"
elif jours_restants == 1:
    # "expires in 1 day"
elif jours_restants <= 0:
    # "expired X days ago"

Six tiers. Six native OS notifications (Windows Action Center, macOS Notification Center, libnotify on Linux), handled by the plyer library which gives you a unified cross-OS API. No need to roll your own ugly modal popup — the OS handles it, with its native look, and the user sees them even when the app is minimized.

This is exactly the kind of feature where Tkinter forces you to hack a Toplevel floating window. With PyQt5 + plyer it's five lines, and it actually feels right.

Brick 3 — Automated HTML email with a chart attached

This is where LiMa gets serious. On every alert cycle, if any licenses are in the red zone, the app:

1. Generates a pie chart (Matplotlib) of "expired vs not-expired"
2. Saves it as a PNG
3. Sends a formatted HTML email with the PNG attached

def generer_graphique_pie(self):
    expirations1 = 0
    non_expirations1 = 0
    for row in range(self.tableau_licences.rowCount()):
        jours_restants = int(self.tableau_licences.item(row, 2).text())
        if jours_restants < 0:
            expirations1 += 1
        else:
            non_expirations1 += 1
    plt.pie([expirations1, non_expirations1],
            labels=["Expired", "Not expired"],
            colors=["red", "green"], autopct='%1.1f%%')
    plt.savefig("graphique_pie.png")

And the send via smtplib:

email = MIMEMultipart()
email["From"] = smtp_user
email["To"] = destinataire
email['Cc'] = copy_mail
email["Subject"] = subject
email.attach(MIMEText(html_body, "html"))

with open(attachment_path, "rb") as attachment:
    part = MIMEBase("application", "octet-stream")
    part.set_payload(attachment.read())
encoders.encode_base64(part)
part.add_header("Content-Disposition", f"attachment; filename={attachment_path}")
email.attach(part)

server = smtplib.SMTP(smtp_server, smtp_port)
server.starttls()
server.login(smtp_user, smtp_password)
server.sendmail(smtp_user, [destinataire] + copy_mail.split(','), email.as_string())
server.quit()

That's it. With smtplib (stdlib), email.mime (stdlib) and matplotlib, you have an email-alerting system that rivals any cloud product. The recipient gets a clean email with a chart. No third-party API. No tokens to rotate. Your internal SMTP server does the job — or Gmail if you don't have one.

The menu: it's a finished tool, not a POC

Before the last brick, here's the dropdown menu so you can see this isn't just a script that draws a table:

CSV import/export, QPrinter printing, A-Z and Z-A sorting, alert toggle, visual statistics (Matplotlib), SMTP configuration, dark/light mode, about box. Everything you'd expect from a finished internal tool, not a prototype. And it all fits in a single lima.py.

Brick 4 — Dark mode in PyQt5, no external library

PyQt5 exposes CSS-style stylesheets. So dark mode is just a setStyleSheet toggle:

def toggle_dark_mode(self):
    self.setStyleSheet("""
        QMainWindow {
            background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
                stop:0 #323232, stop:1 #1a1a1a);
            color: #FFFFFF;
        }
        QTableWidget {
            background-color: #202020;
            border: 1px solid #404040;
        }
        QHeaderView::section {
            background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
                stop:0 #404040, stop:1 #202020);
            color: #FFFFFF;
        }
    """)

No qtdarkstyle, no external theming engine. You write your two stylesheets, you swap them on click. It's just Qt CSS.

Tkinter does have ttk.Style().theme_use(...), but it only covers ttk widgets, not the classic tk ones. For a real Tk dark mode you need a third-party