Principal Software Engineer

I build backend systems, then build the tools to understand them.

Five years at 7Vals on Rails backends and IT-asset systems. I led the CMDB build and I run the Workflow Automation program now. The tooling side got interesting along the way: a Redmine CLI, Claude Code skills, an agent that turns tickets into pull requests.

Lahore, Pakistan. Open to remote or relocation.

Email me Get my resume

8
engineers, as tech lead: 7mo
CMDB to prod

Five years, four things

Selected work

Three things I'd actually want to talk about in an interview.

These projects are part of AssetSonar, EZO's IT asset management product, built by 7Vals.

The sync job that took half a day

Ruby on RailsDelayed JobPostgreSQL

AssetSonar's device sync was taking 12 to 15 hours to run. New hardware wouldn't show up for most of a working day, and customers noticed.

The cause was the ordinary, expensive kind: N+1 queries and no batching, on a table that had been accumulating devices for years. I rebuilt the pipeline around batched writes and cut the redundant lookups.

Under an hour now. The batching pattern stuck around a lot longer than the original fix did. Every MDM integration added since has been built on top of it.

Read the long version →

Before: 12–15 hours
After: Under 1 hour

Same job, same data volume: millions of software records across thousands of devices. The batching pattern it produced is still what every MDM integration since has been built on.

Automation that could branch

Ruby on RailsReact FlowITSM

Automation in AssetSonar used to be a trigger paired with a sub-trigger. Fine for a one-step rule. Past that it ran out of room: nothing chained, nothing branched, and when a rule misfired there was no way to see which part of it had.

It's a node canvas now. Triggers fire on an event or on a schedule, conditions filter with AND/OR, actions chain, and each one branches on success or failure. Every run writes a step-by-step log, so a rule that does the wrong thing can be read instead of guessed at.

I led technical delivery on the replacement. Five months, eight engineers, and a no-code canvas built on React Flow. The work split into HTTP and API execution, expression resolution, event triggers, branching and iteration, data transformation, integrations, and the monitoring that shows what a run actually did.

What makes it composable is what happens after a request comes back. A web request node parses the response into a schema, and every key in that schema becomes a placeholder the next node can read. Arrays split into individual items. Paginated endpoints follow themselves to the end. Above all of that sit pre-built connectors for Entra, Teams, an HRIS, so the common cases never touch auth at all.

An offboarding that used to be four tools and a checklist is one workflow. It runs in customer production accounts, and the numbers aren't mine to publish. It also turns out to be the thing that lands in client demos, which is not what I expected from a rules engine.

It's the program I still run.

Publicly documented by EZO →

A CMDB that actually models relationships

Ruby on RailsPostgreSQLGraph modeling

Most CMDBs are static. An asset points to a user, maybe a location, and that's about it. Anything past that takes a support ticket.

We wanted something that could answer a real question: everything that touches this server, three hops out. I led the design and the build, a data model supporting n-level relationship traversal plus the ITSM-integrated UI on top of it. Seven months, architecture to production, leading a five-person team through it.

More of it was flagged by product as launch work than anything else I shipped that year.

Publicly documented by EZO →

Level 1 is what the graph shows by default. Each card expands to the next level, so this path answers which vendor contract covers the software on one server. Before it, every one of those links was a separate lookup. Drawn from the shipped feature, not a screenshot.

Trajectory

Four titles in five years, and what stayed behind after each one.

Software Engineer
Aug 2021 – Jan 2023
Backend engineering.
Re-architected the device sync from 12–15 hours to under one hour, and built the audit-trail engine from scratch.
Software Engineer (L2)
Jan 2023 – Jul 2024
Feature ownership.
Service Catalog, peripheral device discovery, MDM lifecycle automation, AWS Marketplace. This is where I stopped implementing specs and started writing them.
Senior Software Engineer
Jul 2024 – Jul 2026
Technical lead.
Eight engineers on Workflow Automation, five on CMDB / IT Graph, two on AWS cloud integration. Splitting the work up, deciding who owned what, and reviewing how it got built.
Principal Software Engineer
Jul 2026 – now
Architecture and tooling.
Reviewing designs I didn't write, getting pulled into production problems, and building the tooling below. Still writing code.

Tooling and practice that stuck

Repository-level Cursor rules and Claude Code skills for our Rails/React codebase, merged into the main repo and adopted across engineering.
rmine, plus reusable skills for spec analysis and effort estimation. The team runs it day to day; the numbers on this page came out of it.
Local CI guardrails and Slack-based N+1 detection, so a performance regression is caught before review instead of after deploy.
Airbrake triage: working out who owns a production error and routing it there, so recurring failures stop sitting unclaimed.
A closed-loop agent that plans, tiers, implements, and opens a PR (or escalates) for a Redmine ticket, using the Claude Code SDK. Still a prototype, dry-run tested so far.
SOC 2 remediation and WCAG Level A accessibility work across the Rails codebase, at the level of code fixes and the follow-through to close them out.
A RAG-based Slack assistant that answers Customer Success questions from company blogs and Slack history. In use by the AssetSonar CSM team.

Open source

Public, verifiable, and maintained.

rmine

Redmine CLI with a Claude Code skill built in, plus a companion spec-estimator skill (rmine-skills). Adopted by the team at 7Vals.

View on GitHub →Read the post →

pushed 3d ago

bitwise_attributes

Ruby gem

Packs boolean flag attributes into a single ActiveRecord integer column. Started as an internal pattern I used for two years before publishing it.

View on GitHub →Read the post →

pushed 1mo ago

Why rmine exists

I wanted to know what five years of my own ticket history actually said. Nothing made that easy, so I wrote something: a CLI in Go with a Claude Code skill built in, so an agent can query tickets and time logs on its own instead of me pasting API responses into a prompt.

The rest of the team runs it day to day, and the delivery numbers on this page came straight out of it. Not a demo. Just what the tool actually found.

rmine --help

rmine --help
A command-line client for Redmine

Available Commands:
  issue       Work with Redmine issues
  project     Browse Redmine projects
  skill       Manage the rmine Claude Code skill
  time        Log and manage time entries
  whoami      Show the active profile's user

Flags:
  -o, --output string    table|json
      --profile string   profile to use

Writing

The parts that needed more than three paragraphs.

Aug 24, 2026CloudflarePerformance

The edge said HIT. The browser asked anyway.

Cloudflare was caching this site's assets and reporting it on every response. The browser was still revalidating all six of them on every visit, because of a default header I had never read.

Aug 20, 2026GoAgentsDeveloper Tooling

What changed when an agent started using my CLI

rmine was built for two callers from the start: me at a terminal, and a coding agent. The design decisions that only make sense because of the second one.

Aug 19, 2026AgentsEstimationClaude Code

Three agents that don't trust each other

An effort estimator built out of three subagents. The decisions that mattered were about what to withhold from each one, not what to tell them.

All writing →

By the numbers

I built a tool to analyze my own delivery history. This is what it found.

rmine, a CLI I wrote, pulled five years of my own tickets and time logs and scored them.

years

The short version: I started out implementing specs at 7Vals. Somewhere in there I started writing them instead.

276

feature tickets

72% in production

72% of them shipped to production. The rest were killed, deprioritized, or are still in flight.

Key Features

Product-flagged, go-to-market work. Not the routine maintenance stuff.

promotions

Software Engineer to Principal. Four titles, five years.

months

Zero to production on the CMDB module. Newest number on this list.

Feature tickets per year

276 feature tickets across five years, counted by the year most of the work was logged in rather than the year the ticket was filed. 2026 is hollow because the export stops at the end of July.

Method

Closed issues assigned to me across five years, exported with -o json, then grouped by tracker and by the product's own feature flag. The tool is open source; the Redmine instance behind these numbers is my employer's, so you can read the method but you can't run it. Where a number is a range or an estimate, it's written as one.

Read the source on GitHub

Still running the Workflow Automation program at 7Vals, and figuring out how much of the engineering workflow itself can be handed to an agent without making the output worse.