I work with you from first conversation through last deployment. No handoff, no translation layer. I write the code myself.
Thirty years of engineering judgment plus AI-assisted development. I can see the whole system and still be the one at the keyboard.
I'm not here to write a report and leave. I'm here to ship the thing that solves your problem.
The discovery work, the architecture, the code, the rollout. Same person, one conversation, all the way through.
Developer, architect, CTO, VP. The titles kept changing. The code kept calling me back.
That reaction is what every project is for. Everything else is engineering in service of it.
I listen harder than most developers. I ship faster than most consultants. The overlap is where the interesting work happens.
I understand the business problem. I know what's actually buildable. I start building on day one.
If something in the plan won't hold up, you'll hear it from me while it's still cheap to change course. We work that out together, before the build.
rsync, scp, find and a SQL prompt for a SharePoint library and its lists. I built them because I got dragged into this world alongside you.
See the xfiles suite → Browse all the Microsoft 365 tools →Clean, reshape, profile and query CSV without corrupting a value. The terminal tools I reach for on every data engagement.
See xled → Browse all the tabular tools →Segler shows a DocLang document the way a reader sees it, beside the original page image, so you can catch the line a converter misread and correct it in place.
See Segler → Browse all the document tools →Duckling converts forty-odd document formats to DocLang, Markdown or JSON on your own machine, the models riding inside it, so nothing you open ever leaves the room.
See Duckling → Browse all the document tools →Comma opens a CSV the way a spreadsheet does — a familiar grid you edit by hand — except values stay text and every row you didn't touch is left byte-for-byte intact.
See Comma → Browse all the tabular tools →Blick puts your next meeting, unread mail, Teams chats and presence on one screen — iPhone, iPad and Apple Watch. The day at a glance, without opening five apps.
See Blick → Browse all the Microsoft 365 tools →Slipcase puts a document and the description of it in one container. Open it, read and edit the metadata traveling inside, and hand the file to whatever opens it — the description goes along.
See Slipcase → Browse all the Slipcase tools →Tommy Flyleaf shows the file as a tree and gives every value the right control for its kind — a date, a number, a toggle, a list. You change what a setting is, without minding how it's spelled in TOML.
See Tommy Flyleaf → Browse all the document tools →Zirbe turns every email thread into a conversation, on iPhone and iPad. Real email underneath — no backend, no account, nothing new to sign up for.
See Zirbe → Browse all the apps and classic tools →Essays on the problems the software solves — cleaning CSV without wrecking it, reaching SharePoint from the terminal, Power Automate you can actually read. The thinking behind the work, not just the tool.
Read the writing →Odox is three small, native editors for OpenDocument — Text, Grid and Deck, for .odt, .ods and .odp. Open a file, fix what's there, and save it back, without waiting for a full suite to load.
See Odox → Browse all the document tools →Filebase points at a folder of Slipcase containers and answers a query as rows — title, status, dates, tags — without opening or writing a single one.
See Filebase → Browse all the Slipcase tools →
Client engagements and open source projects. I build both, and they feed each other.
Built the scoring engine, financial model, and contract-to-application mapping for a 600-application portfolio spanning 47 departments. Automated the analysis and handed the team the tools to keep the program running after the engagement.
Joined a seed-stage startup as Interim CTO. The product was a Joomla proof of concept; I rebuilt it from scratch as the sole developer on PHP, hired an onshore/offshore engineering team, and migrated the platform to Java as the product matured. Stayed to close the Series A, then exited.
Designed and stood up a new service offering from concept to recurring revenue. Built the practice, the delivery model, the client relationships, and the team around it. Took it from zero to self-sustaining recurring revenue, and it's still in market today.
Walked into an operating loss and built the systems, processes, and tools that reversed it. That infrastructure is what made the turnaround stick.
As a contractor at the U.S. Department of the Treasury in the late 1990s, I built the pipeline behind the daily report on overnight foreign market movement — the one the Treasury Secretary used to brief the President each morning. It captured market data live off the Reuters feed and produced the finished report end to end. Robert Rubin read it first; Lawrence Summers after him.
Migrated an LNG operator's intranet to SharePoint Modern with a hub-site architecture. Delivered the base framework, branded navigation, and governance pattern in the planned 60-day window, and trained the internal team to own the platform from day one.
Built three Microsoft 365 workflows — Onboarding, Offboarding, and Transfer — to replace a brittle Jotform process. Designed as a stop-gap between an outgrown Paycom and a coming UKG implementation. The stop-gap stuck. Turning scattered SharePoint list data like this into something you can query and bulk-fix is what led me to build xql.
Built parallel SharePoint sites for pipeline and terminal operations (kept separate by regulation) to capture interim directives, track acknowledgements, and notify managers as due dates approach. Replaced a spreadsheet-and-email process that no longer scaled. Building and maintaining Power Automate flows like these by hand is what led me to write paxc, so a flow can be reviewed and versioned like the rest of the code.
Replaced an expert-only Excel tax matrix with a guided form casual users could navigate. The client assumed Microsoft Forms or Power Apps were the only options for a SharePoint-hosted tool; built it as HTML and JavaScript inside a SharePoint .aspx page so the business team could maintain the rules in a plain constants file.
Authored the DFO (Documents for Operation) Handover Master Project Plan and Information Specifications that now govern document and data transfer from EPC contractors to an LNG operator. Translated the CFIHOS industry standard into a working contract artifact through cross-functional engagement across executive, legal, commercial, finance, supply chain, operations, and SSHE groups.
Built a Java service to pull employee data — timesheets, pay history, requisitions, demographics — from UKG (Ultipro) into the client's Azure SQL data warehouse on a nightly cadence. The Power BI team had the analytics skills and UKG had documented its REST API; the missing piece was the integration.
Rebuilt the AFE (Authorization for Expenditure) and JIB (Joint Interest Billing) workflows for a 20-person finance organization that had divested most of its E&P assets but couldn't retire its OpenText subscription while those workflows depended on it. New workflows shipped on Power Automate and SharePoint; OpenText went away. Parallel workstream implemented the records retention schedule on Microsoft Purview to govern the new SharePoint content.
Your Microsoft 365 day on a single screen: next meeting, the rest of today's calendar, unread email, Teams chats with new activity, and your presence. RSVP from the calendar card or directly from the email row. Set your Teams presence and out-of-office without opening Teams. Free. Open source. iOS-first.
Email that feels like texting, for iPhone and iPad. Every thread becomes a conversation: the subject is the title, each reply a bubble, real email underneath. The same person writing you about five different things becomes five conversations, which is how email has always worked; Zirbe just makes it look the way you already think.
A SQL prompt for SharePoint lists and CSV files. Bind to a list through Microsoft Graph, or to a local CSV, then run SELECT, UPDATE, DELETE, and INSERT through one command-line tool. WHERE clauses translate to server-side OData, so even large lists return fast. Writes preview by default, so you see which rows would change before committing. Built for the bulk-edit problems the SharePoint UI gives up on and Power Automate can't fix without Premium.
--exec modesed and awk for tabular data. Regex substitution and a small compute layer over Excel-style ranges in CSV and DSV files, with every edit previewed before it's written. Built for the fixes a spreadsheet makes tedious and a throwaway script gets wrong: strip currency characters, restore leading zeros, normalize casing, compute a derived column.
A read-only profiler for CSV and DSV files. One pass tells you what the file is, what each column really holds, and what will bite you when you clean or query it. The diagnostic first step before you edit or query an unfamiliar file — and it never edits a byte.
Reshape for CSV and DSV files. Pivot, unpivot, split, merge, explode, and transpose a table without ever changing, filtering, or aggregating a value. For when the data is correct but pointed the wrong way for the next step — a wide export that has to go long before SQL can group it, or a cell holding three values that each need their own row.
A CSV editor that works like a spreadsheet — a familiar grid you edit by hand — except it won't mangle your data. It shows a delimited file as a grid and saves it back as the same kind of file, leaving every row you didn't edit byte-for-byte intact; values stay text, so leading zeros and long identifiers survive.
A family of command-line tools that give a SharePoint document library the feel of the Unix file utilities — ftp, scp, rsync, find, and tree, over Microsoft Graph. For the bulk file moves and audits that the SharePoint web UI makes painfully slow.
A small DSL that turns Power Automate's verbose flow JSON into readable source code. Write terse code; deploy real flows. The interpreter paxr runs the same source locally so you can iterate without round-tripping through the cloud designer.
A small web app for creating and sharing single-page HTML files. Sign in, write HTML/CSS/JS in a real code editor, preview in a sandboxed frame, share with other users or invited email addresses, and download the file when you're ready. Built for the kind of one-page experiments that don't deserve a repo.
A drop-in clone of ed, the original Unix line editor, in pure-stdlib Rust. Same interface and command set; friendlier when you're learning. Scripts written for real ed run against ved unchanged.
A line editor you can climb into. Print a range of lines by number, then edit it in place, your scrollback left intact. The approachable sibling to ved: the same line-editing model, but you see the lines you're working on rather than holding them in your head.
A self-hosted identity registry for Microsoft 365 tenants. It hands every person a permanent integer ID, never reused, and records where they appear across HR, Active Directory, and vendor systems, carrying the foreign ID each system knows them by. It doesn't sync, deduplicate, or replace your HR system; stewards assert and Xensus records, faithfully and audited. Useful where stricter tools fail: when the truth is messy and spread across systems that disagree.
The command-line sibling of the Blick iOS app. Run blick and it prints what's next: your next meeting and how long until it starts, unread Outlook email, and the Teams chats with new activity. Email and chats share one numbered list, so acting is a keystroke — read a message, r3 to reply, d2 to mark read, x to clear and quit. No switching between Outlook and Teams to see who's waiting on you.
An editor for DocLang documents — the markup language models read and write. Open a document or archive, read it the way a reader would, correct what the converter misread where you read it, and save the same file with nothing else changed.
Converts Word, PowerPoint, Excel, PDF, HTML, EPUB and forty-odd other formats into DocLang, Markdown, docling JSON, ODT, DOCX or LaTeX, on your own machine. Scanned pages are read by models that ship inside the app, so it works with the network off.
One file holding a document together with the metadata that describes it, so the description travels with it. Slipcase Desktop opens a container and edits the metadata inside; its companion Slipcase Open sends a double-clicked container straight to whatever opens the content file.
A TOML editor that shows the file as a tree and edits every value by its kind, then writes back a file with your comments, key order, whitespace and quoting untouched everywhere you did not edit.
Three lightweight editors for OpenDocument files — Odox Text for documents, Odox Grid for spreadsheets, Odox Deck for presentations. Each opens a file, lets you change what is there, and saves it back as the document it was.
A desktop app for a folder of Slipcase containers: point it at the folder, ask which of the documents say what you are looking for, and read the answer as rows. It never writes a container.
A query language for a folder of Slipcase containers: SELECT, FROM and WHERE over the flyleaf each one carries, so a directory of described files answers “which files say this” from the command line.
Converts Office files to OpenDocument the moment you open them — double-click a .docx, .xlsx or .pptx and it opens as an editable ODF document, for anyone standardising on OpenDocument.
Most engagements start with a conversation about a problem. I listen for a while, ask a lot of questions, and start building. Not a prototype to demonstrate a concept; the thing itself, rough but working, that we can change on the spot while the person who will use it watches.
I stay in the room from that first conversation through the last deployment. There is no handoff. The person writing the code is the person who sat with the stakeholders. I am the one asking what actually needs to happen on Monday morning.
I will tell you when an idea won't work. If you are about to spend money on the wrong thing, you will hear it from me before you spend it, not after. I would rather lose the argument early than build the wrong thing well.
AI-assisted development is a core part of my practice. It lets me ship faster than I used to, but only because thirty years of engineering judgment keeps the code clean. I can tell good AI output from bad output, and I rewrite the bad parts. I also build in the open when I can. Open source is how I stay sharp, how I test ideas before I bring them to clients, and how I give back to the tools I use every day.
Every engagement is a build, even when it starts as strategy. A rationalization study ends with a scoring engine. A turnaround ends with the systems running the new process. The deliverable is working software, not a slide deck.
I have been building software for thirty years. Across that time I worked as a developer, technical lead, solutions architect, CTO, and VP. Each title took me a little farther from the code. I came back to it on purpose.
These days I am at the keyboard on hard technology problems. I analyze the data, build the tools, write the deliverables, and present the findings myself. I use AI-assisted development as a core part of how I work, not a novelty. Knowing what good code looks like is what lets me direct AI output rather than accept whatever it hands back.
Plenty of my career has been spent as a project manager, technical lead, and executive. All of that is still in the toolkit, and I am a strong leader when the role calls for it. But it is not what I am doing now. Right now I am the person writing the code and sitting with the user while they try it. At this level of experience, that is rare, and it is where I am most useful.
My most recent engagement was an application portfolio rationalization for a large municipal government, where I built the scoring engine, the financial model, and the tools that keep the program running after I leave. Before that, client work across energy, startups, and government.
I live in Houston with my wife and kids. When I am not at the keyboard, I would rather be outside with them.
If you have a hard technology problem, I would like to hear about it. I work with mid-market companies directly and with consulting firms as a subcontractor.
The work goes best as a real working relationship — you in the room, me at the keyboard, both of us pushing on the problem. If that sounds right, get in touch.