Internal tools developer

I build the internal tools your team keeps rebuilding in spreadsheets.

Custom Jira apps, Google Workspace web apps and serverless automation on Google Cloud. The kind of software that removes a recurring manual process permanently — with the access controls, audit trail and tests that make it safe to depend on.

  • Atlassian Forge
  • Jira Cloud REST
  • Google Apps Script
  • Cloud Firestore
  • Cloud Run
  • Secret Manager
  • Node.js

What I build

Three things, done properly, rather than everything done approximately.

Atlassian Forge apps for Jira

Custom issue panels, project settings screens, workflow validators, event triggers and scheduled jobs — for the business rules Jira's built-in automation can't express. Runs entirely on Atlassian's infrastructure, so there's no server to own and no data leaving your tenant.

  • Approval gates Jira itself enforces, not just your app's UI
  • Per-project configuration for admins
  • Audit trails that satisfy a compliance review

Google Workspace web apps

Apps Script web apps backed by Firestore or Sheets, authenticated with the Google accounts your team already has. Replaces the shared spreadsheet that everyone can edit and nobody can audit — without buying another per-seat SaaS licence.

  • Role-based access, enforced server-side
  • Append-only audit history
  • Scheduled reminders and SLA escalation

Internal tools & automation on GCP

Web apps and scheduled jobs on Cloud Run, Firestore and Secret Manager — usually wired into a tool your team already lives in, like Jira, so the work lands where people already look instead of in another dashboard nobody opens.

  • Scheduled jobs that are safe to run twice
  • Two-way integrations with loop prevention
  • Structured logs you can alert on

Selected work

Three builds, each solving a problem that spreadsheets and built-in automation couldn't.

Atlassian Forge · Jira Cloud

Release Readiness Gate

The problem

A team's pre-release checklist lived in a Confluence page. It was followed when people remembered, and the only evidence a check had happened was that somebody said so in standup. Jira's built-in workflow validators couldn't express the rules — things like "at least two different people approved, and the assignee isn't one of them".

What I built

A Forge app with a configurable rules engine. A scorecard on every issue shows which checks pass and why, and every gated transition posts a structured audit comment. Project admins configure the rules themselves in a settings screen — nine rule types covering field content, regex formats, labels, issue links, blockers, due dates and multi-person approvals.

Since Jira's own validators couldn't express those rules, the app ships one. The gate runs inside Jira's workflow engine, so it holds on the status dropdown, a card dragged across a board, a bulk change, an Automation rule and the REST API — not only on the button in the app's own panel. Admins attach it to the transitions that matter in the workflow editor, because Jira already owns transition configuration and a second picker inside the app would only drift out of step with it.

The decision that shaped it

Every rule evaluation lives in a pure module that imports nothing from the Forge platform. It takes plain objects and returns plain objects, so the whole rules engine is unit tested in seconds with no Jira instance and no mocks. The adapters around it stay thin enough to review by eye — and the scorecard, the workflow gate, the change trigger and the nightly sweep are four callers of one function, so what the panel shows and what Jira enforces cannot drift apart.

  • Forge UI Kit
  • Workflow validator
  • Jira REST v3
  • Forge KVS
  • Scheduled triggers
  • Jest

Code and case study on GitHub — Release Readiness Gate

Architecture: Jira UI modules and event triggers call resolvers, which delegate all decisions to a pure rules engine, which the adapters then persist to Jira REST and Forge storage. Issue panel Project settings Resolvers · authorisation Rules engine — PURE no platform imports · unit tested Jira REST Forge KVS
Decisions in the middle; I/O only at the edges.

Google Apps Script · Google Sheets

Sheets CRM & Invoicing

The problem

Small teams often split customer details, sales opportunities and invoices across several spreadsheets. The same data is typed repeatedly, pipeline status becomes unreliable, and an invoice can be sent to an address that no longer belongs to the deal's contact.

What I built

A role-controlled CRM web app backed by one Google Sheet. Users manage companies, contacts and deals through focused screens and move opportunities across a visual pipeline. Moving a deal to Won automatically creates a draft invoice populated from the deal, company and primary contact. The app then generates a Drive PDF, confirms the exact recipient before sending, tracks payment state and records the activity.

The decision that shaped it

The spreadsheet is the data store, not the user interface. Every request is checked against the signed-in Google account and its assigned role on the server. Contact, company, deal and invoice records are linked by stable IDs, so editing a contact is reflected when the next invoice is prepared. The Won transition is also idempotent: repeating it cannot create a second invoice for the same deal.

  • Apps Script V8
  • Google Sheets
  • Role-based access
  • Drive & PDF invoices
  • Automated deal workflow

Code and case study on GitHub — Sheets CRM & Invoicing

Architecture: authenticated users work in the Apps Script web app, which enforces roles and coordinates linked CRM records in Sheets with invoice documents in Drive and email delivery. Signed-in Google users Apps Script web app RBAC · CRM workflow · invoice service Sheets CRM data Drive Docs · PDFs Gmail delivery Won deal → draft invoice
One pipeline transition creates the next piece of work automatically.

Google Cloud · Jira · Node.js

SaaS Renewal Tracker

The problem

Companies don't lose money on SaaS because the renewal date surprises them. They lose it because the cancellation deadline passed weeks earlier and nobody noticed. A contract renewing on 1 June with 30 days' notice has to be cancelled by 1 May — and on 2 May the decision has already been made for you. That date isn't on the invoice and isn't in anyone's calendar. The spreadsheet that tracks renewals stores the notice period; it never uses it.

What I built

An internal web app on Google Cloud, wired into Jira in both directions. A dashboard shows annual spend and spend at risk — money on auto-renewing contracts whose deadline has passed or is within a week. A daily job computes every real deadline and raises a Jira task for the contract's owner at 90, 60, 30 and 7 days out. The owner answers by adding one label and closing the task; a webhook updates the tracker, rolls the term forward or cancels it, and records who decided and when.

The decision that shaped it

Two places where idempotency costs real money, both with dedicated tests: running the daily job twice must not raise a second Jira task, and applying a decision twice must not roll the contract forward two years — which would silently push the renewal date out of range and stop it being watched at all. Jira delivers webhooks more than once, so the second one isn't hypothetical. And three callers reach the service, each proving identity differently: Google Sign-In for people, verified OIDC for the scheduler, and a constant-time shared secret for Jira, which can't mint a Google token.

  • Cloud Run
  • Cloud Scheduler
  • Firestore
  • Jira REST + Automation
  • Secret Manager
  • 76 tests, zero deps

Code and case study on GitHub — SaaS Renewal Tracker

Architecture: people, Cloud Scheduler and Jira all reach one Cloud Run service, each authenticating differently; the service delegates every decision to a pure engine and persists to Firestore. People Sign-In Scheduler OIDC Jira secret Cloud Run · one service three callers, three checks Renewal engine — PURE deadlines · thresholds · planning Firestore Secret Manager
One service, three ways of proving who is calling.

How I work

Internal tools fail slowly. These are the habits that stop it.

Decisions in the middle, I/O at the edges

Business rules go in modules that import nothing from the platform, so they can be tested in milliseconds instead of by clicking through a UI. It's also what makes the code reviewable by someone who doesn't know the platform.

The client is never the control

Browser-side validation is for speed of feedback. Every rule is enforced again on the server, identity is always derived from the session, and permission checks fail closed.

No credentials in code

Platform identity and secret managers over key files and environment variables. There should be nothing to leak, and rotation shouldn't need a redeploy.

Quiet by default

A tool that notifies on everything gets muted within a week. I fingerprint outcomes and only speak up when something actually changed — which also keeps the platform bill down.

Designed for the bad day

Overlapping runs, rate limits, half-written batches, records that don't match the documentation. These aren't edge cases in an integration — they're Tuesday. Each one gets a named, tested behaviour.

Handover, not dependency

A README that explains the decisions, not just the commands. Tests that document intent. Configuration your team can change without me.

Have an internal tool project?

Tell me the manual process you want gone. If it's a fit I'll come back with an approach and a fixed scope; if it isn't, I'll say so.

Reach out on Upwork

All contract engagements are handled strictly through Upwork — including scoping, contracts and payment.