There’s more
behind the highlights.

Technical consultant and SQL Server architect/developer — consulting since 1999, an independent practice since 2005, twenty-five-plus years designing, building, integrating and supporting production systems on the Microsoft stack, with SQL Server at the centre of nearly all of it. Works across requirements, data modelling, architecture, development, deployment and long-term production support, usually as the technical resource accountable end to end. The arc that the rest of this document substantiates. For eleven years, 2011–2022, the practice was the inside technology vendor to National accounting practice, a national accounting firm, working directly for its CIO — from a first fixed-fee Financial Dashboard in 2011, through project work and monthly blocks, to 200-hour months and, from 2021, a staffed team. From 2019 through 2022 his own time went entirely to that firm and then to Accounting & advisory group after the 2022 acquisition. In 2023 Accounting & advisory group engaged the practice directly to deliver its Tax Dashboard — a seven-person team, six weeks. In 2026 that CIO became his co-founder: Encapsulated Solutions remains the services practice, and Encapsulated, Inc. is the product company they founded together. In parallel, 2013–2023, a decade as a senior developer for Software-development consultancy on their clients.

A distinctive specialisation combines IRIS STAR Practice Management and accounting-firm operations with database and software engineering. Ten years of work inside STAR and its predecessor, CCH ProSystem fx Practice Management, cover the platform below its application surface: clients, jobs, contacts, staff, rates and custom fields; WIP, billing, receipts, accounts receivable and allocations; entity and ledger structures; stored procedures, triggers, reporting, API extensions and vendor-approved production schema changes. The record includes a CCH-to-STAR firm migration, the re-platforming of a licensed client-onboarding product, seven acquired-firm absorptions across the practice-management estate, historical invoice conversion, a new legal- entity structure inside STAR, financial-report reconstruction, STAR data warehouses and dashboards, and integrations that continued to operate while the underlying platform changed. This is domain knowledge joined to the ability to interrogate, extend, migrate, reconcile and support the underlying system directly.

Two engineering practices run through the whole career. The first is reverse-engineering and reconstructing systems nobody documented — a third-party vendor database traced with SQL Profiler in 2005, a legacy VB6 financial estate transcribed to pseudo-code in 2013, a .NET invoice generator read line by line and re-implemented in T-SQL in 2016, a practice-management vendor's undocumented schema from 2015 onward, a commercial platform's undocumented stored-credential encryption worked out without vendor support so a firm's own data could be reached programmatically, 628 FoxPro program files read to establish what a manufacturer still depended on before migrating it in 2024, and six STAR financial-report procedures decomposed to the staged sources and accounting behaviour that produced their output in 2025.

The second is moving data between systems that were never meant to talk — package migrations in 1999, EDI and US Customs messaging through the 2000s, firm-to-firm practice-management absorptions across the 2010s, and platform migration and warehouse construction today. He did not only write those integrations: he built and operated the integration tier they ran on — a data warehouse per vendor giving each one a queryable local shape, the API-calling layer above it, and, before SQL Server offered native HTTP, the transport that let T-SQL make the calls at all. Multiple products of his were pointed at that infrastructure.

The accounting-firm work sits alongside fourteen years of financial reporting for a Big Four practice, seven years on an FCRA-regulated background-screening platform, a national healthcare-services estate, and a wholesale alarm-monitoring dealer portal. Across those domains, the recurring work is the same: discover how a system actually behaves, make its rules explicit, move or replace it safely, and leave behind something supportable.

Author of FAML (Flexible Application Markup Language) — a declarative UI framework bringing the XML expressiveness of Adobe Flex's MXML into ASP.NET, so that plain XML is recursively converted into the appropriate ASP.NET control tree. Written as his own IP and deployed at multiple clients, years before the mainstream .NET stack offered an equivalent.

Not only a consultant: a builder of licensed products. A client- and engagement-acceptance system built alone over roughly two years, re-platformed once between practice-management vendors, rebuilt across four UI generations on an unchanged server contract, and licensed per user, annually — it carried a national practice's entire acceptance process and recorded 8,473 approval workflows and 21,634 partner approval decisions in production. Alongside it, a financial dashboard, a tax dashboard programme and a dealer portal carry the same architectural signature: the schema is the specification, and the generated system is the deliverable.

Current R&D applies the same retrieval, provenance and verification discipline to AI systems. As of 2026-08-24, the working platform had extracted and modelled a 117,502-message corpus, kept 2,302 findings in a bi-temporal assertion ledger, and recorded 773 independent verification verdicts, including the 211 that did not fully confirm. Alongside it: C# lifecycle hooks and SQL Server telemetry for agent activity, a relational ETL model over raw agent transcripts, governed multi-agent workspaces, and local llama.cpp inference supervised by a .NET service. These are built systems with explicit maturity boundaries, not a list of AI products encountered.

Runs the commercial lifecycle of independent delivery: scoping, proposals and SOWs, milestones, fixed-fee and retainer structures, subcontractor engagement, invoicing and client-relationship ownership. On larger programmes, decomposes work for database, API and front-end specialists while retaining the architecture, delivered artefact and long-term support responsibility.

Longest client relationship: fourteen years. A reporting system designed in 2009 survived two complete source-platform replacements and was still producing monthly financial reports in 2023. A dealer portal built in 2022 remains its company's platform today.

Leader of the STAR SQL SIG, a monthly practitioner forum for STAR firms and SQL developers, attended by IRIS Software Group staff. Presents working systems and publishes the T-SQL behind them. Works hands-on, in production, in T-SQL.

---

The STAR work combines accounting-firm operating knowledge with direct responsibility for the database, integrations, migrations and reporting machinery beneath the product. The examples recur across independent engagements and products rather than describing one implementation.

• Platform internals and production engineering. Worked directly with STAR's schema, stored procedures, triggers, entity and ledger model, custom fields, scheduled processing and high-traffic financial tables. Identified missing primary keys, indexes and unique constraints on core tables and implemented them with vendor approval; redesigned AR-hold processing while reducing latch contention; and made production changes through backups, rollback transactions, audit trails and report smoke tests.
• Practice-management migration and firm change. Supported a firm's 2019 migration from CCH ProSystem fx Practice Management to STAR, retargeting a licensed onboarding system and every dependent application while the product remained available read-only through cutover. Absorbed seven acquired firms into the practice-management estate through staged mapping, renumbering, reconciliation and explicit exceptions; later prepared the estate for merger and retired STAR into a controlled legacy-archive role. On a separate CCH-to-STAR migration, profiled and converted a final cut of 200,066 historical invoice records, including proprietary document extraction, target-key conflict rules, cut-off handling and sampled QA.
• Financial reconstruction and reconciliation. Decomposed the procedures behind Aged WIP, WIP Reconciliation, Bills List, Receipts, AR Aging and AR Reconciliation to the minimum staged sources that reproduced their output, documenting the accounting behaviour behind each. Built STAR reporting and dashboard layers over WIP, net billings, collections and AR; reconstructed point-in-time positions by reversing later activity; and treated reconciliation against each firm's own reports as the correctness standard.
• Integration beyond the vendor surface. Built three custom STAR API extensions for clients/jobs/contacts/staff, WIP transactions and financial reporting where the vendor API did not cover the requirement. Delivered integrations around STAR spanning workflow, CRM, payroll, e-signature, tax, portal and document-management systems; a due-date pipeline with priority matching and exception routing; and a processing-fees application that validated vendor data before posting approved WIP transactions directly into STAR under transactional protection.
• Entity restructuring, reporting and operational continuity. Delivered a client's first multi-entity STAR database after researching the entity and ledger model with IRIS technical staff, then transferred jobs and WIP through reversible scripts and preserved original identifiers, including identifiers recovered from backups. Rebuilt failed SSRS environments, migrated subscriptions by parsing their XML configuration, removed stored report credentials, and verified reconstructed settings to 100% accuracy.
• Independent consulting and peer credibility. Served as sole technical resource on major STAR programmes, worked directly with vendor support and technical consultants, owned production troubleshooting and cutover verification, and led the two-month discovery that preceded a replacement system. Hosts the STAR SQL SIG, where accounting-firm technologists and IRIS staff review working SQL Server, reporting, integration and warehouse designs.

---

This is a recurring capability in system replacement, migration and refactoring, documented across unrelated engagements from 2012 through 2024. Every instance below is from a contemporaneous timesheet or invoice.

• Platform upgrade validated against real workload (2012). Recommended, prepared and supported a SQL Server 2000 → 2008 upgrade, then measured the outcome by re-running the queries from actual production support tickets, alongside index design, testing and a written report.
• Differential test harness at scale (2013). A VB6 financial application was being re-implemented in T-SQL and the results differed. Traced the cause to arithmetic-semantics differences between the two runtimes and proved it by generating and running 40,000 programmable test cases; preserved fractional precision to the final calculation by moving the whole chain to decimal(18,9) and debugging side-by-side calculations.
• Side-by-side reconciliation to zero difference (2016). Converting a .NET invoice-generation application to T-SQL, placed the legacy .NET classes inside a Windows harness so both implementations could be launched together, then ran them side by side — "analysis of differences… adjusting as necessary to produce equal results" — until every difference including the last text comparison was resolved. Followed by a dedicated week forcing leap-year February pay periods on a large sample. Deployed to production with rollback testing and a post-deployment stored-procedure diff between production and QA.
• Self-verification (2017). Where the refactor was his own, prepared side-by-side databases from a production copy and ran manual and proposed stored-procedure logic on both, comparing results across new-period import, existing-period re-import and re-cache paths, and validating expected data and control totals against the non-updated version.
• Byte-level output comparison (2019). When a reporting process had to consume data from a replacement source system, verified equivalence by binary-comparing the generated files.
• Compare-and-rebuild verification (2024). An SSRS subscription migration verified by extracting the source configuration, rebuilding settings from the extracted data, and comparing to 100% accuracy.
• Full-inspection plus sampling QA (2024). A document conversion run of 200,066 records quality-assured by full inspection of the first ten conversions plus one-in-ten-thousand sampling across the remainder.

Supporting discipline used throughout: before-and-after production backups, orphan and cross-system comparison reports, abnormal-number reports, reproduction documentation written before QA deployment, rollback and undo scripts, continue-from-failure logging, and report smoke tests as a deployment gate.

---

SQL Server — 6.5 through 2025

T-SQL (Transact-SQL) at depth · stored procedures · triggers · user-defined scalar and table-valued functions · views and indexed views · dynamic SQL · SQLCLR procedures and functions · MERGE · window functions · CTEs and recursive CTEs · PIVOT · XML and JSON shredding and generation · XML parameters · temporary and staged workloads · table variables · SQL Agent scheduling and job estates · multithreading via a table queue · Database Mail · linked servers · OPENQUERY · OPENROWSET · BULK INSERT with XML format files · synonyms for cross-server abstraction and synonym repointing as a cut-over switch · SQL Server Profiler and Extended Events tracing · execution plans and query tuning · index design, page fill and fragmentation management · columnstore indexes · Query Store · rowversion change tracking with min_active_rowversion() correctness fencing · binary-collation comparison · sp_invoke_external_rest_endpoint and database-scoped credentials (2025) · OLE ServerXMLHTTP REST calls from T-SQL · language extensions (Python) · backup strategy assessment · log and growth health checks · latch-contention diagnosis and remediation · deadlock prevention by imposed lock ordering, proved with parallel test scripts · decimal(18,9) precision preservation · ROW_NUMBER sequencing · version-portable workarounds where a target release lacked a function · Azure SQL.

Production experience by version: 2000 (Background-screening provider, 2011 — scripts written for its constraints), 2008 (upgrade driven and measured, 2012), 2008 R2 (2013), 2008 vs 2012 (deployment differences including THROW unavailability, resolved with RAISERROR), 2012 (matched deliberately as a development target to production, 2016), through 2022 and 2025.

Deliberate positions, stated plainly: SSIS — reads, assesses and documents existing package estates, including documenting the purpose of every package in a client estate, but writes ETL as maintainable T-SQL by choice rather than building packages. Table partitioning — used internally, not yet on a client engagement. Not claimed: SSAS, Power BI, CDC in production, replication, Availability Groups, database DevOps (SSDT/DACPAC, CI).

Data engineering and warehousing

ETL (Extract, Transform, Load) and ELT pipeline design, written as maintainable T-SQL (Transact-SQL) by choice — see the deliberate position on SSIS (SQL Server Integration Services) above, which is read-and-assess rather than build · EDI (Electronic Data Interchange) · source-to-target mapping · data profiling · cleansing and standardisation at the source boundary · deduplication under target-system constraints · in-flight deduplication in a table variable so the vendor's source data is never modified · referential verification against lookup tables · metadata-driven code generation (MERGE synchronisation generated from catalog views) · slowly changing history and point-in-time reconstruction by reversing subsequent activity · frozen historical periods · incremental synchronisation · chunked and batched processing at two-million-record scale with configurable batch sizes · caching table-valued-function results into indexed tables · moving scalar functions into the ingest path to remove per-query work · restructuring so preprocessing happens during import · reconciliation and exception routing · provenance columns · default-row and tripwire idioms · versioned snapshot storage on columnstore · pre-compiled navigation views · compare-and-rebuild verification · one-in-N sampling QA.

Reporting

SSRS (SQL Server Reporting Services) — authoring, deployment, migration between systems, subscription migration by RDL and XML parsing, pass-through and application-driven connection architecture eliminating stored credentials from reports, scale-out troubleshooting, full rebuild and bulk re-import · Excel report generation via the Excel 2003 XML file format and via Office automation · LINQ to XML generating SpreadsheetML with a server-query-driven column configuration · Crystal Reports · PDF generation via SSRS, NReco and iTextSharp · custom reporting-rendering engines built to mimic SSRS over non-SQL back ends · Business Objects / WEBI · SAP HANA.

IRIS STAR and accounting-firm practice-management systems

IRIS STAR Practice Management — production technical depth:

• Platform and financial model: schema and database internals · stored procedures · triggers · entity and ledger model · clients · jobs · contacts · staff · rates · custom fields · due dates · WIP · billing · invoices · receipts · accounts receivable · allocations · write-offs.
• Migration and firm change: CCH ProSystem fx Practice Management to STAR · acquired-firm data absorption · client and engagement renumbering · identity cross-references · source profiling · cut-off handling · historical invoice and document conversion · multi-entity restructuring · legacy-archive strategy · reconciliation and reversible deployment.
• Reporting and financial reconstruction: STAR stored-report decomposition · Aged WIP · WIP Reconciliation · Bills List · Receipts · AR Aging · AR Reconciliation · SSRS authoring, environment rebuild and subscription migration · data warehouses · financial dashboards · point-in-time reconstruction.
• Extensions, integration and operations: custom STAR API extensions · production schema changes with vendor approval · upgrades · performance and latch-contention work · vendor escalation · integrations spanning workflow, CRM, payroll, tax, e-signature, portals and document management.

Other accounting-firm platforms integrated, migrated, extended or supported: CCH ProSystem fx Practice Management (VPM) · IRIS Practice Engine · CCH Axcess (including ELF) · SurePrep · SafeSend · GoFileRoom · FirmFlow · DocuWare · Confirmation.com · DocuSign · Adobe Sign · ADP Workforce Now · Salesforce / Force.com · HubSpot · Informatica · BPA Platform / TaskCentre · Microsoft 365 and Graph · Epicor.

Integration and APIs

API (application programming interface) design, consumption and lifecycle operation · REST and JSON · SOAP and XML web services · service-oriented architecture · OAuth and token lifecycle management including refresh and recovery after vendor-side change · OpenID authentication applications · paged retrieval with continuation and restart · reusable HTTP infrastructure hosted inside SQL Server · vendor API extension development where the vendor's own API did not cover the need · EDI · US Customs messaging (AMS, deconsolidator and air-carrier roles) · IBM WebSphere MQ · Descartes Air Manifest · Rapiscan · Socrata open-data API consumed from inside SQL Server with paging and MERGE sync · EMC Documentum · Taleo · Kenexa · SonicRecruiter · Accio · eScreen · Qwiz · Previsor · Ceridian · ePay · IVR and fax workflow triggers · SMTP/CDO · browser automation and web scraping as an integration path of last resort · UiPath.

Application development

Current — C#/.NET · VB.NET · ASP.NET (MVC, Web API, Blazor Server, Blazor WebAssembly) · gRPC · WPF · WinUI 3 · Windows Services · .NET BackgroundService/Worker Service · IHttpHandler · WebMethod page methods · Word and Excel automation · Python via SQL Server language extensions. Adoption is fast when a platform adds reach: a working Blazor + gRPC prototype sixty-six days after Blazor's general availability (November 2019), and Adobe Flex 2 training exercises five months after that platform's release (2006). Earlier and still readable — VB6 · Visual InterDev · WinForms · UWP · AngularJS with UI-Router, directives with isolated scope and injectable data services · KnockoutJS · Bootstrap · jQuery · Adobe Flex 2/3 and Flash Builder with WebORB remoting · ActionScript 3.0 · ASP.NET AJAX and UpdatePanel · FAML (Flexible Application Markup Language — his own declarative UI framework) · LINQ-to-SQL · ADO/ADO.NET · DAO · RDO · SHAPE · COM/DCOM · MTS · ActiveX · Windows API · ADSI/LDAP · CDO/CDONTS · VBA · VBScript · JavaScript · HTML · Task Parallel Library · dynamic assembly loading. Legacy exposure — QBasic · COBOL I & II · Microfocus COBOL · JCL · CICS · MVS/TSO.

Identity, security and compliance engineering

Third-party security-assessment remediation as a named release · web-application penetration-test review · vulnerability-scanner (Acunetix) test design · a purpose-written harness to reproduce a denial-of-service condition · PII masking across SSN, date of birth and driver's licence · regex-based validation auditing across product versions · Windows authentication through the middle tier via the My.User façade · database EXECUTE grants driving the application's authorisation model · row-level security enforced inside stored procedures, shaping navigation as well as data · authorisation re-keyed from user ID to session ID across procedures, tables and functions · hand-built token session layer federated to OneLogin · Duo MFA · SAML and SSL certificate lifecycle · RSACryptoServiceProvider and JWT · audit trails · per-user and per-query back-end telemetry · randomised audit-selection with a tamper-evident audit log · single sign-on against an existing identity store rather than a second one · FCRA workflow (adverse action, consent, restricted states, state summary of rights, Form I-9, MVR, adjudication) · ACA compliance reporting · malware and encryption incident response.

Reverse engineering of undocumented vendor security schemes, for authorised integration. Where a commercial accounting practice-management platform stored credentials under an undocumented encryption scheme and exposed no API, he reverse-engineered the stored-credential format without vendor support or documentation so that a firm's own data could be reached programmatically on its own behalf. Applied, not academic: the objective each time was an integration that the vendor had left no supported route to, and the work was done for the firm that owned the data. The work required reverse engineering, applied cryptanalysis, binary and scheme analysis, security research and integration engineering under adversarial documentation conditions. ⚠ The method, the algorithm and the affected vendor components are deliberately not recorded anywhere in this document — other firms still run that software, and a résumé states what was done, never how. Those platforms have since moved to token and OAuth-based authentication.

Tooling and delivery

HP Quality Center · JIRA · TFS · Visual SourceSafe · AtTask/Workfront · Basecamp · Beanstalk · Fiddler (used as a code-review instrument from 2012) · Postman · Citrix · SQL Profiler · schema comparison for upgrade scripting · VM and VDI provisioning · change-request authoring · release notes · dual-server smoke testing · incremental per-page deployment scripting · rollback and undo database scripts · defect triage across parallel trackers · formal SDLC practice — authoring and reviewing Functional Requirements Documents (FRD) and Business Requirements Documents (BRD) under a documented software development lifecycle during the Background-screening provider years (2007–2013), one specification carried through fifteen numbered revisions · estimation.

Libraries and components

EPPlus · iTextSharp · NReco · PDFSharp · OpenPop · BitMiracle · WebView2 · Browserhawk · Web TWAIN · Visual Studio LightSwitch · ng-file-upload.

Databases beyond SQL Server

Microsoft Access 2.0 through 2021 (including front/back-end split architectures and size-limit remediation) · Oracle 8i · DB2 · SAP HANA · Visual FoxPro legacy estates (program .prg files and report forms, read and migrated rather than maintained) · ODBC against legacy and third-party sources · Infor M3 as an ERP system of record.

AI and current work

Azure OpenAI embedding and language models called directly from SQL Server 2025 via external REST endpoints and database-scoped credentials · retrieval over relational data · LLM-assisted analysis of large undocumented schemas · a production web-based AI-assisted extraction engine initiated from SQL Server, replacing a robotic-process-automation implementation.

Models, APIs and agent runtimes. Anthropic Claude — Claude API, Claude Agent SDK, Claude Code · Azure OpenAI and the OpenAI API, GPT-class models · Codex · GitHub Copilot · OpenAI-compatible HTTP endpoints.

Patterns applied in shipped systems, not surveyed. RAG (Retrieval-Augmented Generation) · retrieval and recall over a relational corpus · embeddings and semantic search · structured output and schema-constrained generation · tool calling / function calling · multi-agent orchestration and agentic workflows · evaluation and verification harnesses · human-in-the-loop approval gates · bi-temporal assertion ledgers with provenance and supersession · context-window budgeting treated as an engineering discipline rather than a prompt-writing habit.

Local and on-premises inference. llama.cpp · GGUF model files · quantisation / quantization (Q4_0, Q8_0) · full GPU offload · 128K context windows · multi-instance model serving supervised by a .NET BackgroundService / Windows Service with HTTP readiness gating, graceful start and stop, and structured logging.

AI observability and governance — his own instrumentation. Agent lifecycle hooks compiled as a C# binary and wired into the agent runtime · agent-step telemetry landed in SQL Server · a tool-invocation ledger correlating each call to the hook that triggered it, with request and response payloads, success status, error capture and per-call duration · JSONL transcript shredding into a queryable relational model · pre-commit validation gates · dual-agent instruction construction, so two different agent runtimes read identical rules by construction rather than by discipline.

⭐ Judgment about where AI belongs, stated publicly. Presented to a peer audience of practising professionals (SQL SIG, 2026-07-02, recorded): scoping each reverse-engineering task to a single session so the context window is respected — "when you respect the context window and you're more specific, you get much more favorable output" — which reduced a ~200 KB stored-procedure script to a ~15 KB working equivalent for the filters required, more than a tenfold reduction, across two or three iterations. Full autonomy granted deliberately on a low-stakes internal site and withheld from the design work: "when it takes over, I kind of feel like I lost control." On that internal site, the model was pointed at a knowledge base he authored of his own Blazor component library, so the generated application was built from his components rather than from generic scaffolding.

---

The recurring design decisions behind the work below, stated as patterns because they transfer. Each is documented at two or more unrelated clients.

System design, declarative interfaces and generated contracts

• Externalise embedded logic into configuration the system already owns. A recursive configuration table with nested levels and stored procedures evaluating access from it (2014) — carved out and shipped as a standalone settings service reused across applications; territory logic lifted out of a view into a translation table and then generalised into a rules table (2015); per-company logic consolidated into a single stored procedure driven by XML configuration (2019); and in 2025, described to a client as "a precisely programmed system with a recursive configuration table… avoiding the unpredictability of modern AI-driven solutions."
• Database-driven, database-controlled architecture. Application logic implemented as stored procedures and CLR procedures so behaviour, auditing and activity logging live in one place and are inspectable — used to make an entire e-commerce platform auditable down to click level.
• The middle tier as an automation layer. Designing the service tier to expose every capability the UI offers, without the UI — so the system can be driven programmatically, tested headlessly, and integrated against later without rework.
• Declarative UI over imperative control code — FAML. Authored Flexible Application Markup Language, a framework that brought the XML expressiveness of Adobe Flex's MXML into ASP.NET: developers write plain XML, which is recursively converted into the appropriate ASP.NET control tree, giving a high-level language for expressing user interfaces instead of hand-coding controls. Centralised repeated UI construction across multiple web applications so presentation change is made once, and carried between clients as his own IP. In his own description, it was "my way of writing something in ASP.NET so I didn't have to really use ASP.NET" — build the pleasant language, then stop touching the unpleasant one. The same move recurs: FAML over ASP.NET, then a UI contract expressed in SQL over a client framework, then an extension layer over WinUI 3. Every configuration engine he built afterwards is the same instinct.
• Read an opaque system, transcribe it, re-implement it, prove equivalence. SQL Profiler tracing of a vendor database (2005); legacy VB6 logic documented as pseudo-code before conversion (2013); a .NET application traced by "taking notes in the form of SQL" and the notes converted to runnable queries (2016); a .NET re-save tool converted over several hundred hours (2017); the STAR estate throughout.
• Metadata-driven generation over hand-written repetition. Synchronisation code generated from the catalog rather than typed per table — the schema is the specification. Taken furthest in the onboarding product, where four generators emit the synchronisation procedures, the XML shredders, the validation preambles and the data-transfer classes for two client languages, all from the same catalog.
• One name, resolved everywhere — no routing table. Where a client must reach a server operation which must reach a database routine, make the identifier itself the binding: the same dotted name is the client call, the server namespace and method, and the database schema and procedure, resolved by reflection at call time. Nothing to configure, nothing to keep in step, and a new operation exists the moment it is named consistently. Applied across three products and two decades — a remoting alias binding a client class to its server twin, a server schema derived from the calling namespace, a folder path that is the database schema, a service method whose name is the procedure it calls, and finally a REST endpoint whose URL is the stored procedure name. Long-lived contract: one product's server contract served four client generations in three languages — Adobe Flex, a WinForms rebuild, a WPF module and a Windows host — without changing, because the contract was the name rather than a document. A commented-out ActionScript call sits beside the C# that replaced it in the same file: same procedure, same arguments, different decade.
• Give code the vocabulary of the work it is doing. Where SQL is performing application-shaped work, it should read in the idiom of an application: collection types named as their .NET equivalents so a set is visibly a set and a keyed bag visibly a dictionary; helper functions carrying the names their Visual Basic counterparts already had. The same instinct produced a declarative markup language for ASP.NET and, twenty years later, an XML form of executable C#. Borrowing a familiar vocabulary is cheaper than teaching a new one, and the reader arrives already knowing what the names mean.
• Render on the server, display on the client. A pattern held consistently for fifteen years: the server sends the screen, not the data. Every figure crosses the wire already formatted, carrying its own label and its own tooltip; bars and chart segments carry their own colours; even chart axis bounds are computed server-side. The client's whole contribution is layout. Two consequences make it worth the discipline — presentation changes ship without rebuilding or redistributing a client, and the same screen can be configured per firm from the server alone. The boundary is drawn deliberately, not dogmatically: in the one module where users edit rather than read, formatting moves back to the client, because a value being typed has no server-rendered form yet.
• Run both generations and discriminate; do not cut over. When something upstream changes identity mid-flight — a vendor's API, a firm's organisational model, a client platform — carry both versions side by side behind an explicit discriminator and let callers resolve which they need. Done three times: two generations of a tax vendor's API served simultaneously through a mid-season identifier change; a firm's pre- and post-restructure org model held in the same object with a year-suffixed second set, the newer one carrying a dimension the older lacked; and four client generations supported on one unchanged server contract. A cutover is a date on which everything must be correct at once; this is the alternative.
• Derive the data-access layer from the schema's declared relationships. Rather than mapping objects to tables by hand, walk the foreign-key graph and generate the joins and projections — then let the caller state which related entities it wants and return exactly those. The relationships are already declared; restating them in a mapping layer only creates a second thing that can be wrong.
• When reality does not fit the rule, model the exceptions as data. Discrepancy and mismatch tables that are first-class domain objects rather than log lines; a register of the clients whose historical numbering never followed the scheme, consulted by the allocator; reconciliation views that report both directions of a failed match. Auto-resolve only what is unambiguous and make the remainder visible — never guess to keep a batch clean.
• Make the system explain its own decisions in the user's language. Approval routing that arrives with a written reason for every participant and every skipped step; configuration tables that render each row as an English sentence describing what it does; error messages that accumulate every problem and present them together rather than one at a time.

Migration, verification and operational safety

• Reversibility as a first-class requirement. Production data transfers built so they can be undone during testing; production changes tested inside rollback transactions; cross-reference tables mapping new identifiers back to originals, including identifiers recovered from backups; rollback and undo database scripts introduced as a standing release procedure.
• Verification designed in, not bolted on. Compare-and-rebuild logic proving a migration to 100% accuracy; record-count verification inside transactional protection; full inspection of the first N conversions plus one-in-N sampling; report smoke tests as a deployment gate.
• Treat any system you do not control as untrusted input — most of all where your code deletes. Where a load removes rows absent from the source, assert a plausible minimum volume before the merge is permitted, and an upper bound on repairs, so a systemic fault stops the run rather than "correcting" thousands of rows. A vendor API that silently returns a truncated result set — or a dependent table someone else empties on another server — will otherwise delete the client's data, and it will look like a successful run. Written in advance, on the reasoning that a dependency outside your control eventually fails in a way nobody authorised.
• Put the application where it can be changed without a deployment. In the service-oriented database architecture used here, the interface definition, the behaviour behind each control and the business rules live in the database, so the parts that change most often are updated on the fly, with no downtime and no software rollout. The same move across twenty years — FAML rendering markup from the server, window and view definitions returned as XML in the onboarding product, a tax dashboard's grid composed cell by cell in SQL. Where the deployment path belongs to somebody else's team, this is what makes shipping possible at all.
• Build the missing primitive, then stop working around the gap. FAML gave ASP.NET the declarative markup it lacked; an OLE-Automation HTTP path gave T-SQL an API client years before the platform had one, and the .NET-execution step that solved binary payloads became SQLX; a base class gave WinUI 3 the modal dialog it does not provide. In each case the workaround was written once, given a name, and then used as though the platform had always supported it.
• Continue-from-failure over all-or-nothing. Long-running conversions that log, survive and resume, so a run of tens of thousands of records ends with a short, workable exception list.
• Priority matching cascades. Where records must be matched across systems on imperfect keys, a ranked sequence of match rules with explicit exception routing for what falls through — rather than a single join that silently drops rows.
• Move the work to ingest time. Restructure so preprocessing, function evaluation and control-total caching happen during import, leaving the read path with nothing to compute.
• Shape the storage like the screen. A dual raw/cache model mirroring the application's own hierarchy with parent totals maintained from child actions — then deliberately collapsed back to a single set of tables once it proved more complex than it was worth.
• Never mutate the client's or vendor's source data. A production failure caused by duplicates in a vendor table resolved by deduplicating in flight, in a table variable, leaving the source untouched.
• Abstraction of cross-server dependencies. Synonyms and configuration-driven endpoints so a system's physical topology can change without rewriting its logic.
• Decomposition to the minimum sufficient source. Taking an opaque report or procedure and reducing it to the smallest set of staged sources that reproduces its output exactly, then documenting the business behaviour that explains the difference.
• Replace your own design when the evidence says to. Documented reversals include an XML parameter approach abandoned for temp tables after three days; the dual-cache model above; an input-table strategy dropped after a design meeting; and a pure Web API re-platform shipped as a hybrid because the pure version was not worth the cost.

Reuse, delivery and technical leadership

• Externalise what everyone does badly, then give it away. Rollback scripts introduced as a standing procedure (2011). A .NET console application invoked from stored procedures, built pro bono, so a firm's SQL developers could perform file, rendering and email operations "without requiring them to learn new skills" (2023).
• Decompose work so others can execute it. Where volume required additional hands, broke work into pieces specialists could own without needing the client or system context — a structured codebase curriculum for a new developer in 2011, one legacy application each for two developers in 2013, and named specialists with formal roles from 2020.
• Backward-binary compatibility discipline in long-lived component estates.

---

Encapsulated Inc., New York, NY · Co-Founder and Systems Architect · 2026 – present

Software product company serving accounting firms, co-founded with the former CIO of a national accounting practice, following an eleven-year working partnership. This is the current product expression of the consulting practice: turning practice-management, financial-reporting and integration work into reusable infrastructure. Alongside the products: services around them, and AI-native services and AI products — the retrieval and verification platform described under AI platform below is the first. Lineages: the Financial Dashboard descends from the first dashboard built for the firm in 2011; SQLX descends from the self-funded HTTP-addressable database layer the team began in 2019. Responsible for architecture, data and all technical delivery. Products are governed operating surfaces built over the systems firms already run, rather than replacements for them. Four shipped products carry his architecture — Client Onboarding, Tax Dashboard, Financial Dashboard and SQLX — with governed execution, traceability, audit-ready visibility and long-term supportability as the stated design objectives rather than feature count. (Public bio and product line: encapsulated.com.)

• STAR data warehouse — built and delivered, across sixteen working versions. Ten exploratory versions, each a complete working database answering one design question, published in full with working T-SQL — then six implementation versions, each frozen as a correctness anchor before the next began so every version could be tied back to the one it replaced. The delivered warehouse carries 79 tables, 588 columns and roughly 22.7 million rows of practice-management history: WIP, time, billing, allocations, write-offs, invoices, receipts and AR.
  • The ten were run as experiments and reported as experiments — including the ones that failed. Versions 3 and 4 generated the whole ETL from metadata contracts held in table types and read through catalog views; version 5 deleted all of it and went back to synonyms and plain views, because the generator cost more to maintain than it saved. Publishing the abandoned branch is the part most engineers leave out.
  • Four ideas survived all ten and are stated as such: clean at the borders, capture meaning as columns, gate computed questions rather than parameterising them, and sync incrementally behind a correctness fence.
  • Fail loudly rather than corrupt quietly. A "tripwire" predicate — a CASE that casts a self-describing error message to int when a deal-breaking condition appears — makes the query die with its own explanation instead of admitting bad data. Carried from the first version to the last.
  • Derive rather than store: an opening balance is not kept, it is recovered from the closing balance by identity — closing less write-offs, bills, adjustments, expenses and time — so any as-of position is reconstructed rather than snapshotted.
  • Make drift structurally impossible: every summary report is mechanically a GROUP BY over its own detail query, so there is one implementation rather than two that can disagree; and every row carries provenance columns naming the source rows behind it, which makes drill-back a column set rather than a feature.
  • Built as composable functions, not stored reports. 88 inline table-valued functions against 15 procedures and 3 views: the model is expressed as functions the optimiser inlines and callers compose, so a new report is written by combining what exists rather than by adding another procedure that duplicates it.
  • 203 foreign keys across 79 tables, and every table keyed. Warehouses routinely drop referential integrity for load speed; this one enforces it, so a load that would corrupt the model fails at the boundary instead of surfacing months later as a reconciliation dispute.
  • A source-shaped layer and a modelled layer, one-to-one — 74 objects each side — so extraction and cleansing happen at the source boundary and the modelled side never inherits the vendor's shape.
  • Incremental synchronisation on SQL Server rowversion behind a min_active_rowversion() correctness fence, metadata-generated MERGE synchronisation from catalog views, foreign-key verification against lookup tables, and point-in-time reconstruction by reversing subsequent activity.
  • 48 synonyms form the single seam to the intake layer, so the warehouse can be repointed at a different source copy without touching a modelled object.
  • No columnstore, no partitioning, no temporal tables, no in-memory OLTP. The performance is in the model and its indexes rather than in features that would have to be justified to someone else's DBA.
  • Published in full with working T-SQL at sqlsig.com/events/meetings/2026-07-02.
• Financial Dashboard. An IRIS STAR financial operating layer covering WIP, net billings, collections and AR, with budget, current-year, prior-year, period-to-date and year-to-date context. Frozen historical periods; pre-compiled views for navigation speed; firm-shaped hierarchies assembled from standard STAR dimensions and firm-specific custom fields; columnstore indexes for versioned snapshot storage. Nine organisational hierarchies and fourteen role perspectives over one set of numbers, so the same period can be reviewed as offices, service lines, industries, entities or people without rebuilding anything. The lower reporting pane is contextual — ranked views where ranking is meaningful, and detail views where it is not, decided from the selected node's type rather than by the user. Entirely server-rendered: every figure arrives pre-formatted with its label, its tooltip and its colour, so the screen can be changed for a firm from the server alone.
• SQLX — a language and runtime that give T-SQL the reach of .NET. SQL Server keeps orchestration, scheduling, permissions, state and audit; only execution leaves the database, and it can be redirected to another node. The design principle he states for it is "centralise orchestration, not compute."
  • It began as a missing primitive and became a product. Years before SQL Server offered native HTTP, he drove outbound API calls from T-SQL through OLE Automation and the XMLHTTP component. When vendor APIs returned binary payloads T-SQL could not accept, he built an endpoint that takes a fragment of .NET source, executes it to perform the real call, and returns the payload base64-encoded. That step — calling .NET from T-SQL — is what SQLX now is.
  • He designed the language it executes. An XML form of executable C# — object construction, method invocation, property and field access, variables, casting, control flow and return shaping — a transpiler and runtime, with a precompile/compile/execute/return pipeline. Whether a name is a constructor, a field, a property or a method is resolved from the type itself by reflection, so the author never declares it; overloads match on the arguments' actual types.
  • A shipped library of 69 stored procedures turns the runtime into something a SQL developer uses without learning the language underneath it:
    • 43 procedures across six .NET namespaces — System, System.IO, System.IO.Compression, System.Net, System.Net.Http and Microsoft.VisualBasic.FileIO — named so that knowing the .NET name means knowing the procedure: [System.IO].[File.ReadAllText], [System].[Uri.EscapeDataString]. File system, compression, HTTP and path handling, all callable from T-SQL.
    • 5 procedures wrapping third-party libraries — HtmlAgilityPack for HTML-to-XML, NReco for HTML-to-PDF, PdfSharp for image-to-PDF — so a stored procedure can produce a document.
    • 15 procedures covering a CRM's REST API, with batch create, update and archive.
    • 6 core procedures that are the entire runtime contract.
  • REST APIs become addressable by URL. An endpoint's address is the procedure name, so a vendor's API is browsable in the object explorer, the call site documents itself, and there is no client library to generate or regenerate — full create, read, update and archive, not read-only ingestion.
  • The library is the adoption path. Most users never write the language: they call a procedure that already exists, and the ones who need something new write it once and add it to the library. Capability arrives as a stored procedure, which is the unit a SQL developer already knows how to find, read and call.
  • The execution log is written as the equivalent C#, so a developer debugging a script reads back what it meant in the language they already know.
  • In the products that use it, every external call is a procedure invocation with a correlation identifier and a companion results table, so integrations are traceable and replayable rather than fire-and-forget.
• Client Onboarding. Governed intake of new clients and engagements into practice management, with approval rules, origination logic and downstream propagation. 115 tables, 139 procedures and 16 schemas, carrying a national firm's entire client- and engagement-acceptance process.
  • Underneath it is a query compiler written in T-SQL. A field dictionary of 141 declared fields and 44 queryable entities is compiled into a navigable graph — 2,268 join paths and 38,025 resolved columns, six relationship levels deep — from which the engine assembles queries on demand. 72 compiled queries are persisted from 5,450 SQL fragments as a cache, so the cost is paid at compile time rather than per request.
  • The declaration is the only thing maintained. Callers name the entity and the related entities they want back; the joins and projections are derived from the foreign-key graph the database already declares, so a relationship is never restated in a mapping layer that can drift from the schema.
  • Four generators sit on the same metadata — emitting the synchronisation procedures, the XML shredders, the validation preambles and the data-transfer classes for two client languages — plus a validation layer that refuses a configuration the graph cannot satisfy, rather than failing later at query time.
  • The framework was proved by reuse, not by design review: the same engine was pointed at a partner review process it was never built for, and replaced an email-and-spreadsheet workflow without changes to the engine.
• Tax Dashboard. A governed operating surface for live 1040 delivery — one row per return, assembled across practice management, workflow, tax software, e-signature, client portal and document management, with controlled action from the row. Configured per firm rather than shipped fixed: which system supplies workflow, which signature vendor, which document system, which columns and terminology. The grid itself is defined server-side, so a firm's operating language can be reflected without changing the client.
• Current platform work: Azure SQL, and Azure OpenAI embedding and language models called directly from SQL Server 2025.

AI platform and agent infrastructure — built, running, and measured

Own R&D, built on his own instance. All counts measured 2026-08-24 and still growing — they are a snapshot of live systems, not a finished total.

• A knowledge-extraction and verification platform over a 117,502-message corpus spanning 2000-02 to 2026-08 across seven mailboxes, plus 2,675 attachment files swept — the entire archive read, not sampled. Retrieval-Augmented Generation (RAG) with the verification layer most implementations leave out:
  • A bi-temporal assertion ledger — 2,302 findings, 2,206 current and 96 explicitly superseded — so a corrected belief supersedes its predecessor instead of erasing it, and the superseded version stays readable with its date.
  • A provenance graph of 2,754 derivation edges, so any claim traverses back to the messages it came from.
  • An evaluation harness that re-derives claims independently and records a verdict: 773 verdicts — 562 confirmed, 105 partial, 106 unverifiable, 0 refuted. The counts are published as-is, including the 211 that did not fully confirm, because a verification layer that only reports its successes is not one.
  • A recall procedure as the single query entry point, and a governed promotion path — nothing enters durable knowledge by being written down mid-task.
  • A priced, dated engagement history reconstructed from the corpus as evidence rather than memory: 221 invoices across nine clients, 2006-11 to 2026-08, reconciled against 35 recorded payments.
• An agent-observability database — instrumentation of the AI development process itself. 125,099 recorded agent steps across 23 distinct lifecycle events (tool invocation before and after, sub-agent start and stop, session start and end, context compaction, permission request and denial, prompt submission), landed in SQL Server from a C# hook binary wired into the agent runtime. Alongside it a tool-invocation ledger: 210 invocations of a custom SQL-harvest tool he wrote and called from inside the agent loop, each row carrying the request and response payloads as XML, the correlating hook, success status, captured error and elapsed duration — plus 36,281 structured log rows. Purpose: an agent that records every structural change it makes can be told what changed before it reads the next question, instead of rediscovering the environment each session.
• An AI-observability ETL platform that shreds raw agent transcripts into a relational model. 2,677 JSONL transcript files → 154,490 raw lines → 154,166 entries → 122,801 content blocks → 48,506 prompts, merged with an 89,537-row hook store and 7,216 catalogued schema objects. The relational model makes aggregate questions about agent behaviour directly queryable by a SQL developer instead of leaving them trapped in append-only logs.
• Local LLM inference hosting — in progress. A .NET BackgroundService / Windows service that supervises multiple llama.cpp llama-server.exe instances: HTTP readiness gating with a 180-second deadline, graceful start and stop, IAsyncDisposable, child stdout/stderr routed into structured logging, and connection-string configuration. Configured for two concurrently hosted quantised models — a small Q4_0 and a 27B Q8_0 — both at 131,072-token (128K) context with full GPU offload. ⚠ Stated at its real maturity: the process supervision works; the SQL-driven configuration it is architected for is still being built, and the sample configuration is currently hardcoded.
• A governed multi-agent workspace, and the governance is the artefact. 697 commits in one month (2026-07-23 to 2026-08-24). Dual-agent instruction construction — one instruction file is included by reference from the other, so two different agent runtimes read byte-identical rules by construction rather than by anyone remembering to sync them. Twelve numbered shared rules, each recording the specific failure it guards against, so a rule can be weighed against its purpose when two conflict rather than applied blindly. A pre-commit validator gate — forty contract checks — that blocks a commit rather than reporting drift after it.
• Roughly two dozen of his own databases on one instance, named by domain rather than by project, with explicit version lineage carried in the name — a four-version product line, a six-version warehouse lineage, and separate databases for the website, the membership register, and each research line. The naming and the versioning are the architecture claim: a database is addressable by what it is for, and a version is never overwritten by the one that replaces it.
• SQL Server 2025 calling external APIs directly from T-SQL, demonstrated live against a commercial CRM — pulling records down and pushing data back up — and framed as vendor-neutral across practice management, e-signature, document management, payroll and directory platforms.

Presented publicly, client-anonymised, under his own name — a monthly SQL special-interest group he hosts for accounting-firm technologists. The 2026-08-06 session (1h 27m, multiple firms represented, recorded) walked a peer audience through four working databases, and opened on the practice question rather than the technical one: how a firm bills for work that AI has made three times faster — realisation, metered AI cost as a line item rather than overhead, fixed-fee and project-based pricing, and the argument that a productivity tool is a reason to hire more people and point them at more work, not fewer. The technical half covered a column-selective virtual copy of a practice-management database that keeps itself current in about two seconds including deletes — caught by a bucket-signature strategy, because a rowversion watermark cannot see a deleted row at all — a warehouse built entirely on that copy so no query touches the live system, holding 66 assertions against the firm-level configuration switches that make one firm's data differ from another's; an instance that remembers every structural change ever made to it, through server-level DDL triggers over unioned catalog views; and a separate agent-telemetry database capturing lifecycle events, tool calls and execution logs.

Encapsulated Solutions, Inc. · Founder / Lead Architect and Developer · 2005 – present

Independent consultancy and contracting vehicle. Full lifecycle delivery for accounting firms and, earlier, a broad range of commercial and public-sector clients. The accounting-firm practice combines IRIS STAR and CCH practice-management internals, SQL Server engineering, financial reporting, migration, integration and long-term production ownership. Sole technical resource on most engagements; on larger programmes, decomposed the work for additional developers who did not know the client or the platform, and retained the design and the client relationship. Products were built on unbilled time and then either licensed per user or delivered within engagements.

The practice's shape over time. A one-person practice from 2005 to 2018. In 2019 the first developer, a specialist developer, and in 2020 the second, a second specialist developer — independent developers under their own single-member corporations, working exclusively with the practice and presented to clients as its team. In 2019 the team also began self-funded infrastructure — an HTTP-addressable database layer — that was later used at National accounting practice and became products: allyourdb.com, then sqldeveloper, then SQLX. 2020 added two fixed-hour integration projects, HubSpot and ADP. From 2019 through 2022 his own time went entirely to National accounting practice and then Accounting & advisory group. In 2023 the team scaled to seven — four core and three specialists — for the six-week Accounting & advisory group Tax Dashboard implementation. The practice's other engagements in those years — Healthcare services provider to 2021, Life-safety monitoring provider Monitoring 2022–23 — ran through Software-development consultancy, and Life-safety monitoring provider was carried mostly by the team .

Commercial and engagement-model practice — twenty years of independent delivery, twenty-five in consulting:

• The engagement model matured deliberately, and the instruments show it. Early statements of work carried no milestones, no deposit and no change-order clause, and invoiced only on completion — while naming scope growth as the principal risk. Later proposals were rebuilt around benchmarks, milestones and review points, a tiered engagement model, and a confidentiality agreement. He wrote the governance his earlier contracts lacked, having learned the cost of its absence from his own engagements.
• The change that mattered commercially was the unit, not the rate. Work moved from hourly billing to fixed-fee, milestone-based and monthly-retainer structures, with the majority of the largest engagement's value billed on something other than an hour. Scoping discipline came with it: narrowing a stalled proposal to a defensible core is what gets it signed — one rescope turned eleven weeks of silence into a signature in two days.
• Full commercial lifecycle, unaccompanied: proposal and SOW authorship, scoping and rescoping, rate and renewal negotiation, subcontractor engagement under NDA, invoicing, collections, and client-relationship ownership from first contact to close-out.

---

Accounting & advisory firm · 2022 – 2025

Sole technical resource across IRIS STAR production support, upgrade and estate assessment, multi-entity restructuring, financial-report reconstruction and SSRS modernisation; also led discovery and replacement delivery for the firm's sales-tax process. A sixteen-month programme followed two and a half years of STAR production support.

Documentation, upgrade and estate assessment

• Contracted to document an existing STAR system and perform the STAR upgrade under fixed fee. Inventoried the databases across the estate; health-checked log, growth, page-fill and index size and usage settings; analysed performance bottlenecks; reviewed and assessed every SQL Server scheduled job; evaluated backup strategy; documented the purpose of all SSIS packages and all TaskCentre tasks; documented the system in preparation for upgrade; then executed the upgrade working with the vendor.
• Decomposed six STAR financial report procedures — Aged WIP, WIP Reconciliation, Bills List, Receipts, AR Aging and AR Reconciliation — to the minimum staged sources that reproduce their output, and documented the accounting behaviour behind each.
• Began a STAR data warehouse centred on clients, jobs and staff and their supporting dimensions.

A new legal-entity structure inside STAR

• Delivered the first multi-entity STAR database in the client's history. Researched the entity and ledger model with the vendor's Practice Management support lead and a technical consultant before making changes.
• Wrote scripts identifying affected job, staff and contact records; scripts injecting company, bank and ledger records; discovered the VAT, service-line and job-type cross-reference tables; built transfer scripts with reversibility so the whole operation could be undone for testing; added audit-trail logic and custom metrics for contacts with no service-line designation; refactored so every batch followed one logical pattern in a single execution; tested against multiple fresh STAR database instances.
• Investigated AR reconciliation discrepancies statement by statement inside the stored procedure, comparing outputs across database instances, and built a dedicated database to run and record the output of each step with dynamic attachment to databases and version-specific logging. Resolved faulty vendor logic with a placeholder-jobs workaround preserving old entity links in the report.
• Production deployment with pre- and post-deployment backups and report smoke testing, test environments refreshed to mirror pre- and post-production states, and the deployment documented. Two hotfixes followed — reversing jobs, renaming, duplicating, status changes and reactivations, all recorded in the audit trail — then residual cleanup traced to the deployment gap period.
• Phase 2 prerequisites: a cross-reference table mapping new job IDs to original job IDs, inclusive of all IDs including those later deleted, recovered from database backup instances, with 28 complex cases resolved individually. Then mass-WIP transfer and mass-job-close scripts, and a restructured WIP relieved report eliminating loops and temporary tables.

Production support and process redesign

• Redesigned the AR Hold process — the stored procedure that changes client status at 90 days delinquent — rewriting the datasource logic with corrected conditions and dissecting the query to reduce latch contention on STAR's core high-traffic tables. Added locked clients to the notification path, updated client and job statuses, ensured unique audit-trail entries, resolved duplicate logging to the suspended table, tested in production inside a rollback transaction scope, and monitored the scheduled overnight run.
• Wrote a universal dependency-scan script to determine safely whether a malformed client record was referenced anywhere in the database before deletion; handed it to the firm's own developer for reuse, after which recurrences were resolved without him. The root cause was subsequently identified by the firm as a defect in the vendor's web interface.

SSRS modernisation

• Root-caused permission discrepancies between service accounts, then implemented application-driven pass-through connections using STAR's PDM and StarPMWeb configuration model, eliminating stored usernames and passwords from reports for security and portability. Replicated production SSRS to development and verified reports by parsing RDL XML, establishing a consistent standard for STAR SSRS environments.
• When Microsoft's restore-and-upgrade path failed on a scale-out deployment error, opted for a complete SSRS reset and fresh setup, then re-imported and tested 105 reports.
• Migrated SSRS subscriptions between systems — interpreting XML for parameters, delivery details and scheduling; identifying and preserving repeating XML elements for multiple filters; converting hierarchical data to flat JSON; matching previous parameters to the new system while maintaining ordinal position; and rebuilding settings from the extracted data, verified to 100% accuracy with purpose-built comparison tooling.

Internal tooling, delivered pro bono

• Because the firm's limited programming infrastructure meant prolonged development times for common tasks, externalised the essential functionality into a reusable database invoking an internal .NET console application from user-friendly stored procedures — equipping database developers with tools previously unavailable to them, "without requiring them to learn new skills." Paired with a SQL Server Reporting App managing subscription data and delegating file operations and SSRS web-service communication through the console app, generating reports to disk and distributing by email with logging that prevents repeat sends.

Discovery and the sales-tax replacement

• Led a two-month discovery engagement across the firm's server estate and system landscape.
• Designed and prototyped a browser-automation extraction engine unified across multiple client-side JavaScript frameworks to replace a manual sales-tax filing process. Initially implemented in UiPath, then transitioned to a web-based AI-assisted engine initiated from SQL Server, optimising website navigation, reducing manual effort and minimising future maintenance. The replacement completed end-to-end sales-tax filings and franchise extractions in production.
• Built a client-onboarding product for a second firm — a self-updating modular application with built-in automatic user authentication eliminating additional logins, a Startup Form Invitation Dashboard, and a dynamic form engine driven by a recursive configuration table.

Substantial work on this engagement was delivered pro bono, with a standing discount applied across the final year.

Regional accounting practice, Chicago, IL · 2024

Specialist data-extraction and document-conversion resource on the firm's CCH ProSystem fx Practice Management to IRIS STAR Practice Management migration, working alongside the vendor's implementation team.

• Profiled the source invoice table — 196,957 rows, no primary key, one null document individually documented — and analysed duplicate invoice numbers arising from reversals and cancellations (195,452 unique, with the full duplicate distribution recorded).
• Decrypted and decompressed 787 MB of proprietary encrypted document data using the vendor's own libraries, producing 3.5 GB of RTF, then converted it to 3.0 GB of PDF via Word automation.
• Applied a target-system rule: because STAR requires unique invoice numbers and the source contained duplicates, selected the latest version of each invoice by highest internal ID, while preserving every superseded version under a naming convention permitting later removal.
• Quality assurance by full inspection of the first ten conversions plus one-in-ten-thousand sampling across the run.
• Established the migration cut-off with the vendor — a fixed date, plus the invoice population that breached it because related payments fell the other side of the line.
• Re-ran the process against the final conversion cut of 200,066 records, diffing against the Phase 1 snapshot to identify changes, isolating the two invoices whose identity had changed, and offered the client both a two-file adjustment and a pre-merged full replacement.

Engagement closed cleanly; invoice settled early.

Consumer-products manufacturer, Long Island City, NY · 2024 – 2025

Watch and consumer-products manufacturer — the one engagement outside professional services in this period, and the one that put a legacy 4GL migration and retail EDI back in front of him at the same time.

• Migration of a legacy FoxPro estate. An inventory of 628 FoxPro program (.prg) files and report forms, deliberately partitioned into the superseded set and the live set before any code was moved, so the migration had a defensible boundary rather than a best guess about what was still in use. Reading a 4GL estate to establish what a business still depends on is the same problem as reading an undocumented schema — the artefact is different, the method is not.
• Retail EDI integration through SPS Commerce. ASN (Advance Ship Notice, EDI 856) and invoice transactions, ship-confirm error handling, and the value-added network (VAN) path, against Infor M3 as the ERP of record — extending an EDI and customs-messaging practice that began at the freight and forwarding clients in the 2000s.
• Data access and movement: ODBC against the legacy estate and ZappySys connectors for the integration path, with a team member carrying the EDI workload under his direction.
• The pattern he names across three decades of clients: a business-critical system built by its users out of whatever tool was to hand — a spreadsheet at one client, an accreted key-issuing table at another, FoxPro .prg files here. "Three clients, three decades of accreted workarounds, one pattern." Recognising that class of artefact quickly, and migrating it without breaking the business that grew around it, is the transferable skill.

National accounting practice, New York, NY · 2011 – 2023 · twelve years

The firm's inside technology vendor for eleven years, working directly for its CIO — the principal technical resource across practice management, reporting, integration and operations, from a fixed-fee Financial Dashboard in 2011–12 and a fixed-price project in 2013, through a monthly retainer, to 200-hour months and a multi-person delivery programme. Over the relationship he built and licensed products, replaced and extended vendor integrations, supported the firm's CCH-to-STAR migration, absorbed seven acquired firms' data, rebuilt reporting and tax-delivery workflows, and kept the resulting systems in production. Accounting & advisory group acquired the firm's non-attest business effective January 2022; the engagement continued through the transition (Accounting & advisory group billing, 2022–2023, by invoice), and in 2023 Accounting & advisory group engaged the practice directly for the Tax Dashboard.

• The client-onboarding system that replaced the firm's use of Salesforce. Built on his own unbilled time, then licensed back to the firm; in use for years with near-zero support issues. Its descendant is Encapsulated, Inc.'s Client Onboarding.
• The 2019 STAR re-integration, in one month. Re-pointing that onboarding system from CCH ProSystem fx to IRIS STAR — injecting clients, jobs, contacts and staff directly — took a month, and the depth of platform knowledge it produced left him training on STAR rather than being trained.

Practice management and platform migration

• Reverse-engineered the incumbent Informatica-to-VPM integration from SQL Server traces, then replaced it with a direct Salesforce-to-VPM integration built in versioned releases — metadata-driven downloads, validation of both source and target before insert, audit trail, SQL Agent scheduling, and eventually bi-directional synchronisation of correlation data back into Salesforce. Delivered through six versions in a single month.
• Later built a competing client and opportunity onboarding product that allowed the firm to migrate off Salesforce entirely. His first product, built entirely alone over roughly two years — originally against CCH ProSystem fx Practice Management, then re-platformed onto STAR — and the point at which his practice moved from selling consulting hours to licensing software. It is a client- and engagement-acceptance system, not a data-entry form:
  • Parent/child account hierarchy with entity types, relationship partners, industry and subindustry groups, offices, billing types, affiliate referrals and practice purchases.
  • Project opportunities classified by service-line group, service line and project type, with suffix, year, recurring flag, project fiscal calendar, estimated fee and target realisation.
  • Origination economics — percentage splits across up to four originating partners plus business-development awards, each validated to total correctly.
  • A professional-standards quality gate. Submission is blocked behind an eight-point risk checklist covering prior-year concerns, integrity of client management, fee-collection history, rate realisability, expertise and staffing capacity, and litigation exposure — each requiring an explanation, or an explicit "no concerns exist" declaration.
  • An eight-step approval workflow with role-based routing — project partner, quality-concern approver, subindustry group leader, situation-dependent subindustry leader, service-line group approver, practice-group approver, business-development-award approver and final reviewer — each step tracking request date, response date, response and comments.
  • Origination policy enforced as executable validation, not guidance: originating-partner percentages must total exactly 100; a single originating partner is capped at 75 per cent, obliging a second partner or the house partner to take the remainder; an international affiliate-network referral requires the house partner at a minimum share and forbids business-development awards; any award raises that minimum again.
  • Due-date opportunity generation, file attachment, and discrepancy detection against the practice-management system.
• The approval chain is returned as prediction and history in one contract. Before submitting, the user sees every step that will be required, who will have to approve it, and a sentence in plain English explaining why that person is on the chain — or why a step does not apply to this opportunity. Steps with no eligible approver remove themselves, so one fixed process yields a correct, different chain per opportunity. Approvals could be given from the approval email itself, with links that expire by workflow state rather than by timer, and a proxy approval rewrites the record to name whoever actually acted.
• Ran as the firm's live client-acceptance process, at scale — 8,473 approval workflows and 21,634 recorded partner approval decisions across 7,722 project opportunities, against 46,877 accounts and 126,309 projects, with near-zero support issues, and licensed to the firm per user, annually.
• Architected so that one name routes itself through all three tiers. A single dotted identifier is simultaneously the client-side call, the server-side namespace and method, and the database schema and stored procedure — resolved by reflection at call time, with no routing table, service registry, configuration file or controller anywhere in the product. Every user-facing window has a server-side counterpart class, so the entire application can be driven programmatically without its UI — the same design he had used a decade earlier on an e-invitation platform.
• The data-access layer is compiled from the database's own declared foreign keys. A metadata routine walks the foreign-key graph six levels deep to derive every reachable column and every join needed to reach it, then generates and caches the SQL per requested projection — the client names which related entities it wants back and receives exactly those, a selective-projection contract of the kind later popularised by GraphQL, implemented in T-SQL. A second generator emits computed columns giving every table in the schema the same presentation contract, which is what allows a generic client to render any entity.
• Four code generators drive the codebase from the schema itself — emitting the synchronisation procedures, the XML shredding functions, the validation preambles, and the data-transfer classes for both client languages, which is why the VB.NET and ActionScript object models correspond one to one.
• Rebuilt across four technology generations as the platform moved: Adobe Flex 3 → WinForms on .NET 5 → a WPF module → two Project Reunion / WinUI 3 iterations, with the automation layer carried intact across the rewrites. Moving the entire front end from Adobe Flash to .NET 5 changed thirteen of the sixteen shared server-side files by exactly two lines — the namespace declaration. Only the data-access plumbing was rewritten.
• Verification built as a deliverable. When the firm supplied its approval-rules spreadsheet, he imported it and then wrote a validator whose entire job was to disprove it — flagging identifiers that did not exist, names that disagreed with the live system, and columns that should have been uniform and were not. Only the validated result was allowed to configure the product.
• Supported the firm's 2019 migration from CCH ProSystem fx Practice Management to STAR. Retargeted the client-onboarding system from CCH to STAR — which required understanding clients, jobs, contacts, staff and their related tables well enough to inject records directly into STAR — and converted every dependent application with it: the dashboard, onboarding, SurePrep processing fees, CCH Axcess charging fees, FirmFlow due-date integration, the budgeting module and the WIP/AR evaluation tool. The system ran read-only through the cutover window so the practice could keep working while the platform changed underneath it.
• Trusted with write access inside both practice-management vendors' own production databases, with their agreement. Under CCH that included implementing the firm's client- and engagement-numbering scheme — per-office code prefixes, seeded sequences, collision handling, and an explicit register of the clients whose historical numbering had never followed the rule. On re-platforming to STAR he reduced that vendor-side footprint from fifteen objects to one: a single procedure taking a document in and returning correlation identifiers, with round-trip identity verification and collision detection on the way back — moving validation back onto his own side of the boundary while making the integration provably correct.
• Converted CCH Practice Management's proprietary encrypted invoice format to PDF by leveraging the vendor's own library to decrypt it, so historical invoices could be carried into STAR.
• Performed post-cutover reconciliation: identified jobs missing for existing due-date records, and client-state values that had not carried across from the legacy system.
• Identified missing primary keys, indexes and unique constraints on core STAR tables and implemented them with the vendor's approval — the tables appeared to have been deployed from staging without them.
• Authenticated custom applications against the practice-management system's existing user store, so staff kept one set of credentials and no second identity store had to be maintained.

Firm consolidation and data absorption

• Absorbed seven acquired firms' client and engagement data into the practice-management estate between 2016 and 2022 — imports into both VPM and Salesforce, partner by partner, with prepare-test-import-verify cycles; engagement renumbering logic; legacy duplicate-ID resolution; work-type mapping; a merge-client capability; transferred-engagement cross-reference tables; and side-by-side comparison reporting between old and new firm data.
• Built an engagement exporter end to end — UI, stored-procedure logic, lookup tables, deployment — working around a SQL Server version incompatibility with the acquired firm's database by scripting and transferring, testing in production inside a rollback transaction, then refactoring to synonyms to abstract the cross-server dependency.
• Two of those absorptions are documented in month-by-month detail and show the method rather than the outcome. The Acquired accounting practice absorption (2016) ran through new-engagement and new-client loading, Acquired accounting practice-specific work types, an Acquired accounting practice engagement exporter, merged-client transfer scenarios, cross-server integration, transferred-engagement cross-references and Acquired accounting practice-derived budgets — concurrently, on a live platform. The Acquired accounting practice integration (2018) is the cleanest example of the ingestion pattern end to end: an application written to parse and analyse the supplied text files, everything normalised into a single flat file, loaded to a table, reconciled, then inserted into staging client, engagement and project tables with client-number mapping and explicit overrides, before scripting the cost-centre and accounts receivable data across. The reusable shape: parse to one flat representation, land it in staging, reconcile before it touches the live estate, and keep the mapping and its overrides as data rather than as code. Applied across seven acquisitions over six years.
• Merger data preparation for Accounting & advisory group (2022): analysed client-number inconsistencies against parent/child relationships; identified inactive master clients still holding active children; and explained STAR's data model and table relationships to the acquiring organisation's team. When client numbers were renumbered, built the cross-reference table and logic that kept due-date reporting working, then cleansed the supplied spreadsheets by stripping erroneous prefixes from client codes.
• Retired STAR to a legacy-archive role after the firm consolidated onto the acquirer's practice-management system. Because STAR writes log records whenever the application is used, the database could not simply be made read-only — so client creation was disabled at the application level and through every integration, preserving the archive for former clients who return years later. Only the last three years of active clients moved to the acquirer's system; longer-inactive clients remained in the archive.

Integration and applications

• Built three custom STAR API extensions where the vendor's own did not cover the need — clients/jobs/contacts/staff, WIP transactions, and financial reporting data (WIP, billing, collections, AR) — plus the equivalent three for CCH Practice Management, and a FirmFlow API extension for batch workflow processing the vendor's API did not support.
• Built reusable HTTP/REST infrastructure inside SQL Server and a configuration-driven FirmFlow API layer with JSON array parsing and paged retrieval with manual continuation on error.
• Built the FirmFlow-to-STAR due-date pipeline, including a priority matching cascade with validation and exception routing for unmatched records.
• Migrated 22,120 document records between GoFileRoom drawers with index-key conversion, logging and continue-from-failure — reduced to 19 failures, then resolved.
• Delivered a Processing Fees application performing analysis, calculation, processing and posting of CCH Tax and SurePrep processing fees from raw vendor spreadsheets, showing valid/warning/error records and then posting valid records directly into STAR's WIP table transactionally, bypassing STAR's manual import procedure.
• Delivered a nightly STAR-to-HubSpot synchronisation covering clients (with parent/child, entity types, offices, marketing groups and affiliated referrals) and projects (service-line groups, service lines, types, statuses, recurrings, partner industry groups and offices), plus live-period financials keeping current- and prior-year net billings in step at both project and client level.
• Delivered a STAR-based WIP/AR evaluation tool migrated from the CCH equivalent, rebuilt to pull from STAR with user-entered write-offs and reserves and adjustable realisable WIP; and a Flash Dashboard (WPF) integrated with STAR.
• Built the Organizer Listening Mailbox through four major versions — reading mailboxes without Outlook, HTML-to-PDF conversion, migration to Microsoft 365 Graph with Azure app registration and token refresh, configurable received-date tracking and sanitisation.
• Extended the ADP Workforce Now integration to create STAR staff records with field-level mapping, dimension and permission logic; added a custom field to STAR's staging and production schemas to drive a downstream consent workflow.
• Delivered a DocuSign process — send-envelope API consolidation, production account setup, envelope-status querying and API download of envelope PDFs into GoFileRoom.
• Delivered GoFileRoom drawer deprecation and document rollover, SurePrep binder archiving, a Tax Organizer WPF tool, and a CCH Organizer web module.
• Adopted OPENQUERY to keep his own intellectual property outside the vendor's reach while still integrating with it.

Reporting platform, multiple hierarchies, and legacy rescue

• The multi-hierarchy dashboard (2017) — production origin of "many trees over one set of numbers." The firm's dashboard could show only one organisational tree, because tree identity had collapsed into a single default. He restructured tree processing so several trees carry distinct identities concurrently, made the UI's loading procedures tree-sensitive, introduced a dynamic-linking approach and a scalar level-resolution function so a node's depth was derived rather than hard-coded, carried industry and subindustry grouping through it, reworked security and permissions per tree, corrected budget inconsistencies that only appeared on alternate trees, removed growth-factor logic from tree positions where it did not belong, and synchronised nightly live periods with the budget module. The Financial Dashboard's nine organisational hierarchies and fourteen role perspectives are the mature form of this — the pattern was proved on a production platform nine years before it became a product feature.
• Budget generation as a recurring platform responsibility rather than a report — annual generation, rebuild, correction and deployment across years, budgets derived for acquired-firm data, and reconciliation against realisation / realization reporting and the recurring monthly and mid-month close cycle.
• Legacy reporting rescue — the unglamorous work that keeps a close cycle running. A fragile estate of Microsoft Access custom-reporting databases underpinned real month-end reporting: he restored and re-hosted them across virtual servers, repaired corrupted copies, traced an undocumented Access email module, applied year-end procedures, dissected and documented the undocumented subqueries behind a quarterly reporting workaround, compared patched against unpatched output and validated every repair before handing it back to the business owners who depended on it.

The Tax Dashboard programme

• 2023 — Accounting & advisory group engaged the practice directly to deliver the Tax Dashboard as a staffed implementation: a seven-person team — four core and three specialists — in six weeks . Work beyond the agreed scope was absorbed as a courtesy rather than billed.

A governed operating surface for live 1040 work — one row per return, assembled across practice management, workflow, tax software, e-signature, client-portal and document management, with controlled action available from the row itself. Built to be configured per firm: practice management from STAR or IRIS Practice Engine, workflow from PE or FirmFlow, signature through DocuSign, SafeSend or Adobe Sign, filing into DocuWare or GoFileRoom. Carried roughly 7,500 individual returns in a season.

• Brought in after a year-long rebuild by another vendor failed, and delivered the season. The firm had engaged a separate vendor for a year to reproduce this product and retained him as a second team in case it did not arrive. It did not. He shipped instead — six production deployments inside roughly six weeks, releasing each capability as it became ready because the filing deadline would not move. Some engagement letters had already gone out through the other vendor's system, so he adapted his own product to read that system's database rather than leave a season's records split across two.
• Led delivery of the Tax Dashboard with a development team, adapting the data warehouse mid-project to hold two sets of CCH returns after the vendor changed return identifiers — keeping both API generations live simultaneously behind a version discriminator, so the season continued without a cutover.
• Architected the application so that a single stored procedure is the entire server API — and the reason is a performance requirement, not a preference. Staff worked over a slow corporate VPN, so every request and response is compressed; one entry point means one place to implement that, rather than once per endpoint. That procedure logs the request before anything else runs, gates on the client version, authenticates the Windows identity against the practice-management staff table, resolves the requested action by name, and dispatches through a reflection layer written in T-SQL that reads a procedure's parameter list and invokes it with a typed dictionary. No routing table, service registry or controller exists anywhere in the product.
• Moved the user interface into the database. The server composes each grid row cell by cell — text, icons and their opacity, progress bars with colour and percentage, tooltips, and the name of the action behind every button — and ships it as compressed XML. The desktop client renders what it is given and posts back the action string it was handed; it contains no knowledge of tax, and no hard-coded mapping of any kind. Its entire dependency list is seven packages — no HTTP client, no serialisation library, no ORM, no MVVM framework — and the only outbound call it makes of any kind is a stored-procedure execution. There is nowhere else for application logic to hide.
• Changing the interface and behaviour did not require shipping software. The production system normally changed on the fly, with no downtime; a new desktop binary was reserved for breaking contract changes the client had to be taught about.
• Version-gated the server so a rollout he did not control could not break the season. The desktop application was delivered as a package to the firm's own network team, who pushed it to workstations on their schedule — so mixed client versions in the field were a certainty, not a risk. Because the server reads each caller's version, it emits different actions and different controls to each: older installations kept working untouched while new capability shipped continuously through tax season. Not a one-off: an earlier product of his made the client's build stamp the first argument of the login call, five years before this one.
• Built a twelve-step named integration pipeline across Practice Engine, CCH Axcess, DocuSign, SafeSend, DocuWare and a tax-web application, where the step number and subject are the procedure name, so the run order is legible years later.
• Protected destructive synchronisation with volume assertions — designed in, not learned the hard way. Each refresh asserts a plausible minimum row count before it is permitted to run merges that delete rows absent from the source, paired with an upper bound on correlation repairs per run so a systemic fault halts the run instead of "fixing" thousands of rows. The rule behind it: a database he did not control was treated as untrusted input. A dependency emptied or dropped by someone else, on another server, must not be able to propagate into deletion of the firm's data.
• Self-healing correlation that explains itself. Where CCH allows a return's identifier to change underneath the firm, the pipeline detects the drift, repairs it, and writes a plain-English account of what it changed and why into the run log. Correlation is applied only where a match is unambiguous; everything else is surfaced for a human rather than guessed.
• Used prior-year return intelligence to drive the current-year signature workflow — downloading and shredding the prior-year CCH return to establish filing status, which decides whether the offshore consent form needs one signature or two, and distinguishing five separate reasons filing status could not be determined (return not found, expected-missing for a new client, multiple versions, password-protected, blank status), each surfaced with its own indicator and explanation.
• Removed the manual work between systems: engagement letters and consent forms sent, tracked, resent, voided and marked signed from the row; signed artefacts retrieved from the vendor and filed into document management with their index fields populated automatically; client source documents reconciled from the portal, from manual upload, and from a listening mailbox read through Microsoft Graph — because client documents do not arrive one way.
• Separated visibility from permission — a see-and-do model in which staff can read the state of work their team owns while the right to act on it is computed separately per user and job.
• Diagnosed and permanently resolved duplicate Practice Engine job synchronisation in two phases, with transactional protection and record-count verification.
• Recovered the SafeSend integration twice after vendor site and API changes, including re-adapting eight endpoints individually.
• Migrated the Tax Dashboard to a new server — IIS setup, a .NET web application acting as the Dashboard's API layer, an OpenID authentication application handling CCH access and refresh tokens, four databases relocated, and a SafeSend authenticator console application with a scheduled job keeping a token continuously active.
• Supported a Practice Engine upgrade — full backup, integrations halted, post-upgrade backup and reinstatement, then a comprehensive data-warehouse check confirming complete synchronisation and data accuracy.
• Supported a separate Accounting & advisory group entity running its own Tax Dashboard on an Azure database, resolving a semaphore-timeout fault by excluding the failing step from the full synchronisation.

Team and commercial

• Directed a team of named specialists — database, API, front-end and WinUI developers — whose hours were attributed line by line on the firm's invoices, decomposing work so each could execute without needing the client or system context.
• Licensed two products to the firm per user, annually, alongside the consulting engagement.

Life-safety monitoring provider · 2022 – 2023

Wholesale alarm-monitoring provider, founded 1978, serving independent security dealers nationally across three networked geo-diverse UL-listed monitoring centres, inside a SOC 2 and HIPAA control environment. Engaged through Software-development consultancy — Life-safety monitoring provider was Software-development consultancy client, which billed it.

• Lead developer, with a two-developer team, on the fourteen-month rebuild of Dealer Operations Portal. Built the initial infrastructure and contributed throughout the .NET and SQL Server dealer-portal delivery.
• Scope: 321 tables, 348 stored procedures, 156 views and 29 functions across seven schemas, of which 265 tables model the web API surface — covering alarm history with dispatch attempt logs, alarm companies, police, fire and medical contact numbers, open/close schedules, supervised testing levels, voice recordings, dealer messaging and passcodes, online payment, supply requests, account tracking and advanced search.
• Architected as a database-driven application, consistent with the rest of his work: navigation defined as data (database tables carrying menu items, labels, sort order, URLs, tooltips, visibility and access-control flags); a components framework with column-level metadata; configuration with actions and error capture; session state, context, headers and per-screen variables held in the database; and request telemetry with an in-database debugger and activity log.
• Dealer Operations Portal remains the company's dealer management platform.

Global accounting practice · 2009 – 2023 · fourteen years

The longest client relationship in the record. Financial reporting for an international practice.

• Designed and built a reporting engine — a SQL Server database generating every monthly report for the practice in the Microsoft Excel XML file format: by area, by office, target and focus accounts, and revenue comparisons. Data exported from WEBI Business Objects and imported into SQL Server for analysis, grouping and filtering, with mapping tables for clients, engagements, business units, locations, products and services driving further analysis and change reporting.
• A manual compilation that took a director over a week was reduced to minutes.
• Rebuilt it twice as the source platform changed beneath it — old Business Objects to a new Business Objects generation (2013–2016), then Business Objects to SAP HANA (2017) — with mapping and deduplication work alongside each conversion.
• The system was still producing the practice's monthly reports in 2023, fourteen years after it was designed, having survived two complete source-platform replacements. It ran latterly on a small maintenance retainer.
• Sustained 150–183 hours a month across the peak years, concurrently with other engagements.

Separately, at Global accounting practice Woodcliff Lake — Vector 3.5i: build manager for a large VB6 application estate — multiple system-framework, workflow-framework and presentation projects with many custom and third-party ActiveX control libraries, updated and recompiled while maintaining backward binary compatibility.

Healthcare services provider · 2013 – 2021

National services provider operating across a facilities estate of roughly six thousand sites. Payroll, accruals, budgeting, cost-quoting and time-and-attendance systems. Forty hours a week from late 2014 through 2017, concurrent with the accounting-firm work. Engaged through Software-development consultancy Communications.

A VB6 and VB.NET estate modernised to web (2013–2014)

• Method-first, and documented as method: walkthrough of the legacy applications; debugging the running system to identify global and local variables and database touch-point interfaces; documenting legacy logic and database interactions as pseudo-code; determining the encapsulation strategy against the stored procedures the legacy applications used; converting pseudo-code to SQL via SOA-style stored procedures while maintaining existing logic; test cases and logic-flow testing across user scenarios; a common UI prototype shell for both applications; logic-flow integration sitting with each developer in turn; then non-integrated demo deployment with documented deployment steps before integration against the client's development database.
• Proved the conversion arithmetically correct by generating and running 40,000 programmable cases, tracing runtime arithmetic differences and preserving fractional precision through the final calculation with decimal(18,9).
• Hardened it for production: Windows authentication through the middle tier via the My.User façade with domain parsing; an initialization procedure reading stored-procedure EXECUTE permissions and returning the list of executable procedures, with the UI enabling and disabling sections accordingly; a Windows server built from scratch to replicate the deployment environment; IIS application-pool and connection-string configuration; and a GUID-named download folder to defeat browser caching on file export.
• Legacy archaeology with decisions attached: code-reviewed the VB6 application to determine the purpose of undocumented stored procedures, found two that should be excluded from the new process, and discovered a legacy button operating in two modes — deliberately not reproducing the second because it produced undesirable results.
• Built a metadata-driven validation engine for the import process, "with emphasis on field type, name and value carried down to the UI level", surfacing field-level validation with highlighting; externalised the import folder path to configuration; and converted file-based downloads to in-memory downloads through a generic DataTable routine shared by all four export functions. Added ACA compliance reporting links.

Inheriting a portfolio (2014–2015)

• Took over five undocumented applications from another consultant with one handover session and a machine-versus-source-control comparison — Newsletter, HR, AD Distribution, Employee Directory and Cost Quote. Two of the five did not build. Reconstructed them from source control, and deployed the first to production within four days.
• Built a recursive configuration engine for user-attribute permissions across the Divisions/Regions/Districts hierarchy — a recursive table with supporting tables and nested levels, stored procedures evaluating a user's access from the settings, a recursive UI control mirroring the tree, popup editors for every supported setting, and persistence of the tree structure back to the database. Carved it out as a standalone settings application, deployed to production, with settings categorised by application name so multiple applications could share it. Later secured behind an administrator table with view-versus-edit separation.
• Externalised territory mapping — took an opaque reclassification view, broke it into a dynamically hierarchical structure, lifted the logic into a translation table and then generalised it into a rules table; tested SQL Server synonyms for linking data across databases and servers; and converted core stored procedures into scalar functions for batch testing.
• Traced a latent data-model assumption — regions whose identifying letter differs from their division's — across two applications, using temporary code modifications to size the fix before committing to it.
• Recovered calculated-budget formulas by debugging the running page's client-side JavaScript, because that was where the formulas actually lived.

The time-card / payroll audit application (2015–2017)

• Built end to end, alone, from source-data analysis and Bootstrap prototype through AngularJS with UI-Router, directives with isolated scope and injectable data services, an ASP.NET Web API v2 back end, and a data layer processing two million records via chunked operations with configurable batch sizes.
• Deployed to production October 2015 with SSN masking, row-level security enforced in stored procedures shaping which periods and facilities a user could even see, and back-end telemetry captured per user action and per query.
• Implemented a fair-distribution audit-selection mechanism — custom business logic choosing who is assigned work so that no individual carries a disproportionate share, implemented as a randomised selection of one site per division/region/district each period for regional-manager review, with its own telemetry audit log of assignments reviewed before release. Refined three times across a year as the business rule evolved.
• Built two view modes — district manager and regional manager — as separate templates selected by an address-bar parameter, integrated with browser history navigation, then merged into one template with conditional view logic.
• Re-architected for performance and concurrency: a dual raw/cache table model mirroring the UI with parent control totals maintained from child actions; deadlock prevention by precalculating child totals and updating parents first, proved with parallel test scripts; then a deliberate collapse back to a single set of tables carrying both responsibilities.
• Built a re-import process preserving user selections and audit assignments across a re-import, verified with comparison scripts and a stub-data vendor simulation; and resolved a production hang caused by excessive duplicates in the vendor's table by deduplicating in flight in a table variable, leaving the vendor's table unmodified.
• Built a configuration-driven export engine — column list defined by a server-side query, with the .NET layer emitting SpreadsheetML via LINQ to XML.
• Re-platformed the application onto the ASP.NET Web API project type with a hand-built session/token layer federated to OneLogin, then re-keyed authorisation from user ID to session ID across the UI stored procedures, core user tables and their dependent functions.

Other systems and the source-system replacement

• Converted a .NET invoice-generation application to T-SQL across eleven weeks and proved it by placing the legacy .NET classes in a Windows harness, running both implementations side by side, and reconciling every difference to zero; deployed to production with rollback testing. Preceded by weeks of "tracing the generate-invoices code, taking notes in the form of SQL".
• Converted a .NET re-save tool to SQL scripts over several hundred hours, including upserts for header/detail tables, staffing-grid support and performance work, run in production across the facilities estate.
• Built a public open-data API synchronisation from inside SQL Server — querying an XML web API endpoint, parsing XML into a table function, normalising a flat destination table into related tables, refactoring merge scripts to handle new and updated data, and implementing paging to respect the endpoint's limits.
• Re-pointed a production financial reporting process onto a replacement source system. When the company moved its upstream system to Workday, the existing database and process were retained and fed from the new source; removed the incumbent ERP's dependencies from the post process and from payroll revenue and accruals, consolidated CSV generation into a single stored procedure driven by XML configuration with a configurable record-count threshold for splitting, and verified the outputs were unchanged by binary-comparing the generated files. (Downstream adaptation; the Workday-side data sourcing was performed by others.)
• Built a full-screen mapping application over the facilities estate (2021). A Google Map as the entire application surface rather than a panel inside a page, plotting every facility and its district, regional and divisional managers, with one-click drivable directions between any two points so a nearby manager could cover for an unavailable colleague, and overlaid toggle controls to show and hide categories. Delivered against a hard eight-week cap.
• Delivered a cross-browser and mobile compatibility pass, a file-upload capability built from within a Flex client through an ASP.NET handler, and mass file-set storage with in-memory parsing.
• Led the firm-wide response to a malware attack that encrypted servers across six offices — roughly 130 hours of decryption, remediation and service restoration.

Logistics technology provider, Hewlett, NY · 2006 – 2015

Logistics and customs technology, across two distinct technology generations a decade apart.

• AMS Messaging via Alliance — an ASP.NET web service in C# interfacing to US Customs through a third-party vendor's communication protocols, with a Windows Service retrieving messages from an IBM WebSphere message queue.
• Task Management Web Service — VB.NET, exposing task lifecycle (start, pause, defer, resume, end, delete) with hierarchical tasks, custom properties and dependent tasks, using SQL Server PIVOT and recursive CTEs.
• Task Management Web UI — Adobe Flex 2, with a complete object-oriented ActionScript 3.0 task framework, singleton-pattern service calls, and a merge feature that updated collections in place so grid scroll position survived refresh.
• Import System Web UI v3 — an ASP.NET AJAX application rebuilt as a Flex rich internet application.
• Later generation (2012–2015): AMS batch enhancement; a Web TWAIN scanner integration prototyped into Visual Studio LightSwitch; Descartes Air Manifest XML parsing; and a Rapiscan interface Web API delivered with a 90-day warranty.

Earlier client engagements · 2005 – 2012

Customs brokerage, New York, NY — Customs import system Import Project. A custom application on Visual Studio .NET 2005 and SQL Server 2005 CTPs with full integration to EDITRADE, a US Customs Link third-party product. Reverse-engineered EDITRADE's database with SQL Server Profiler — defining trace columns and events and recording traces to capture result sets and output parameter values. Delivered full data-history tracking through the data tier, Peachtree accounting integration, web services for other offices, and dynamic SQL-generated PDF reporting that replaced thousands of manually created network files, retiring an estate of external Excel and Access VBA tools.

Business media publisher, 2008 — Media-industry directory contact-list extraction. A fixed-price, two-phase web-scraping engagement delivered against a media-industry contact directory and invoiced as two milestones in November and December 2008. Small, but it dates the practice: structured extraction from a third-party web application as a deliberate, billable integration path was running in 2008, between the State insurance fund and Municipal housing authority scraping work of the early 2000s and the vendor-portal scraping of the 2020s — a twenty-year continuity in the same technique, applied whenever a data owner offered no API.

International freight forwarder, JFK Airport, NY. Air AMS Component & Web Service — specification logic, message format and cross-platform protocol handling for passing and receiving US Customs messages, built for both deconsolidator and air-carrier roles. GFX Booking Component & Web Service — booking of pallet and loose cargo. Both sharing a common data-access layer and validation engine, delivered as both web services and class libraries.

Air and ocean freight provider, JFK Airport, NY. IAI EDI — converted a mainframe EDI application into a .NET Windows Service running on the GENTRAN machine, communicating with SQL Server stored procedures to build outbound EDI files, monitoring pickup and issuing email summaries with SSRS-generated reports attached. CM Scanner 2004 — rebuilt a slow, faulty mobile scanning application as a multi-layered .NET 2.0 application with a custom control library, custom grid rows, and a custom updater that exceeded ClickOnce capability.

Local-commerce platform, New York, NY. A location-based grocery and convenience e-commerce platform built entirely in Adobe Flex 3: address geocoding to coordinates, dynamic determination of in-range stores from each merchant's delivery perimeter, checkout emailing an SSRS-generated PDF to both parties, fax to the merchant, and an IVR call confirming receipt — fully automated with no system administration. Plus the merchant portal for inventory, hours, perimeters and fees. Showcased at the NY Web 2.0 and NY Tech meetups for its architecture and performance benchmarks.

Food retail supplier, Naples, FL — gourmet retail website and B2B retail website. A complete e-commerce platform with an Adobe Flex 3 UI over a .NET and SQL Server 2008 back end, designed as a database-driven, database-controlled architecture — all logic in standard or CLR stored procedures, which made every activity including click behaviour auditable and reportable. The B2B site ran on the same engine.

Digital invitations business, Seattle, WA. An e-invitation platform built on his own FAML framework and ASP.NET, SQL Server 2008 with LINQ-to-SQL for the data layer, and a middle tier designed as an automation layer providing all UI functionality without the UI; Flash Builder for invitation builders and guest-envelope animation.

Education technology consultancy / Public broadcasting network — Multimedia classroom system. Three ASP.NET applications and two Windows Services letting administrators build custom multimedia menus browsable by teachers and students. Recovered a strict timeline by consolidating code into shared class libraries, and delivered previously missed specification items including file compression, data casting, and storage expansion across multiple partitions and servers.

IT consulting provider, Edison, NJ — XML reporting engine. Architected an ASP.NET reporting rendering engine that mimicked SQL Server Reporting Services over an XML-fed service back end rather than a SQL Server back end.

Fashion-accessories manufacturer, New York, NY. Brought in as a Microsoft Access specialist to extend a production-quote database and solve its approaching size limit — separating embedded image scans to a file server, loading through an image control for speed, and supporting any scan resolution at actual size.

Also in this period: Global accounting practice · Business news publisher · Municipal housing authority · State insurance fund · Neurological care practice · Hospitality software client · Lifestyle media company · Commercial-services client · Software-development consultancy · Legal-marketing business · Consumer-products client · Technology-solutions provider · IT services and staffing company.

---

Software-development consultancy, Cherry Hill, NJ · Senior Developer (subcontract) · 2013 – 2023 · ten years

Subcontract senior developer for a Cherry Hill, NJ web- and software-development firm. Taken on in January 2013 as a .NET web developer; by 2022 signing as "Amine Fayad, Senior Developer, Software-development consultancy". Worked on the consultancy’s client systems for a decade, in parallel with the independent practice. a second specialist developer also worked on Software-development consultancy clients (Life-safety monitoring provider).

• Legal-marketing business, Mickleton NJ · 2013 – 2023 — the first Software-development consultancy client. A legal direct-marketing business selling daily mail to New Jersey personal-injury and DUI attorneys. Built, in 2013–14 (four milestone payments, May 2013 to December 2014), a court-records scraping and attorney letter-generation system — screen-scraping the NJ Judiciary municipal-court site through a browser emulator — and then operated it as a daily production system for a decade (peak year 2016). In March 2016 rebuilt the production server over a weekend.

• Life-safety monitoring provider · 2022 – 2023 — the Dealer Operations Portal dealer-portal rebuild, described in full under Encapsulated Solutions → Life-safety monitoring provider above; lead developer with a two-developer team.

• Healthcare services provider · 2013 – 2021 — the VB6/VB.NET-to-web modernisation and the 2021 facilities mapping application, described in full under Healthcare services provider above.

Background-screening provider, New York, NY · 2007 – 2014 · seven years

Full-time employee, mid-2007 – mid-2009, then continuing on the same platform through a period working overseas, and finally corp-to-corp through Encapsulated Solutions from 2011 to May 2014. Technical lead on Background-screening platform, an FCRA-regulated background-screening platform serving national enterprise customers.

The consulting years alone account for roughly 5,800 hours; never below 152 hours in any month; four client-side managers turned over while the engagement continued unbroken.

• Built the Recruiter Module from the ground up as a B2B ASP.NET application designed to be maintainable, scalable, extendable and customisable on FAML, his own declarative UI framework, extending the .NET Framework with general-purpose extension methods and domain-specific objects for better testing and error handling. Supported background checks spanning criminal, DMV, credit, education, employment and social-security-trace verification.
• Owned the release train end to end — development, estimation, change-request authoring, release notes, QA and production deployment, dual-server smoke testing, and defect triage across two parallel trackers — shipping hot fixes 19 through 35.
• Owned the remediation release following a third-party information-security assessment, taken through results review with the client's manager and IT lead to a named release.
• Owned a database-timeout remediation release — roughly two hundred hours stabilising it in QA across two months, writing the reproduction documentation before QA deployment and circulating a written analysis to the business. The release later absorbed FCRA disclosure changes and was renamed for them.
• Recommended, prepared and supported a SQL Server 2000 → 2008 upgrade and measured the outcome by re-running queries from actual production support tickets; also delivered index requests and a written benchmark report, a database archiving strategy, and query-optimisation guidelines.
• Delivered a two-month cross-browser and mobile compatibility programme — research, strategy, estimates, business requirements and phased delivery — covering Safari on Mac and Windows, Android, Firefox and Internet Explorer. Reproduced an input-mask failure in a VM, traced it, and moved the fix to IIS response headers so it applied server-side; replaced a browser-plugin chart with a server-rendered image plus client-side capability detection; and removed a Java applet dependency.
• Moved FAML's execution to the client side across roughly nine months — a re-architecture of the framework the whole product was built on — and designed and prototyped its intended successor, WAML (Workflow Application Markup Language), a workflow-oriented markup language of his own devising.
• Built Electronic Wet Signature (EWS) capture into the Candidate Module, so applicant signatures could be taken electronically inside the consent workflow — years before e-signature became routine.
• Built and defended FCRA-regulated workflow — adverse action, consent forms, restricted-states documentation, state summary-of-rights handling, Form I-9, motor-vehicle records, adjudication auditing, fingerprint services, and federal, international and multi-county / metro-jurisdiction criminal search rules — with masking of SSN, date of birth and driver's licence, and regex-based SSN validation audited across two product versions.
• Integrated the platform with the applicant-tracking and screening ecosystem — Taleo, Kenexa, SonicRecruiter, EMC Documentum, Accio, eScreen, Qwiz and Previsor — and resolved a Documentum denial-of-service condition by writing a program to reproduce it.
• Introduced rollback and undo database scripts as a standing release procedure, and consolidated fragmented QA change requests into single executable release instructions.
• Maintained a running product-enhancement backlog derived from the support queue, including architectural and commercial proposals; consolidated a single backlog across every open release; interviewed candidates for the client's team; demonstrated the platform to prospects; and estimated new work on the client's own project-intake process.
• Onboarded a new developer through a structured codebase curriculum — solution setup, module by module, framework, architecture and project history — and progressed within five months to reviewing that developer's independent work and reproducing defects for him.
• Handed the platform over through a scheduled daily transfer across three months when the client moved development offshore — completing the full handover regardless. Recalled five months after leaving to diagnose a production fault; resolved in an hour. One of the developers who took the work over later joined him, working through his own company across multiple clients for years afterwards.

Technology consulting firm, Hasbrouck Heights, NJ · Project Manager, Software Architect/Developer · 2002 – 2005

Technical and architectural lead between IT and senior business stakeholders, defining systems from business needs and comparing implementation cost with expected savings across multiple cost-reduction projects.

Insurance and claims-services firm, Mineola, NY — insurance and claims:

• State insurance fund Web Scraping Project — a C# Windows application performing data entry into a third-party internet application (CS Stars ClaimSuite) using the .NET WebBrowser control with web-scraping techniques, reading and writing across several pages with validation. Eliminated outsourcing expense.
• Check Printer Service — a .NET Windows Service intermediating between a claims-management application and a MICR check-printing application: watching for check files, categorising by check type, grouping and sorting by customer account settings, and launching silent print runs. Eliminated additional client and printer licences and removed the need for check-printer drivers on every workstation, reducing both cost and security exposure.
• Municipal housing authority Web Scraping Service — a C# Windows Service monitoring web activity and injecting business-specific data-entry fields into a third-party application's HTML through the Internet Explorer object model, integrated with the Check Printer Service's database.
• Insurance certificates — an ASP.NET application using a tree structure to allocate, report and maintain State insurance fund certificates, with purchased certificate ranges, next-available-number logic, bulk printing, and deletion with number reuse.
• Email Link-Attachment Service — a .NET Windows Service generating emails carrying links to files rather than attachments, for recipients whose mail systems rejected the attachment types.
• Safety Groups Commissions Generator — an Access front/back-end extension to Peachtree supporting multiple sales-representative references per customer, with a cross-reference matching interface and commission calculation driven by database settings, customer groups and user options.
• Monthly Reports Automation Engine — a VB.NET Excel and Outlook automation engine generating reports from hierarchical client database settings, architected to expose the full Excel object model plus the per-client actions required; column widths, headers, footers, file naming and email formatting all retrieved automatically, with unsent emails staged in the user's Outlook folder for review.
• Quarterly Reports Integration Process — a large contiguous reporting tool over numerous ever-changing client data feeds, each feed isolated as its own logical entity for validation and storage, workflow-driven linking and updates, and intelligent suggestion of non-linkable data to reduce manual intervention.

Eye-care provider, Bergenfield, NJ — Patient Tracker, storing patient application forms through a hierarchical interface, with scanned eye-examination forms persisted to SQL Server. Professional-services firm, New York, NY — Client Tracker, an electronic filing cabinet for scanned documents on SQL Server with tree-view navigation.

IT services and staffing company, East Rutherford, NJ · Lead Software Developer · 2000 – 2002

Full lifecycle development of all in-house systems; automated employee tasks and workflows across every department.

• AminePro.NET — an in-house application built entirely on .NET Beta 2 managing all client services: service-order dispatch and billing, and block-of-time and block-of-money contracts.
• Recruiter XP — an ASP.NET Beta 1 application managing recruiters, jobs, résumés and candidates, with a skills-matching algorithm pairing candidates to jobs, and click tracking on the weekly hot sheet.
• Global accounting practice Asset Management System — applications and tools providing an end-to-end workflow for the Global accounting practice account, from invoice creation through EDI invoice billing.
• IT-services reporting — a data reporting application retrieving hierarchical data with SHAPE, tracking and importing new data, and presenting summary reporting through a hierarchical interface.
• Business news publisher Termination Project — a security-management utility emulating Windows 2000 Active Directory behaviour on a Windows NT platform, deleting disabled Windows accounts and Exchange mailboxes after a defined retention period.
• Résumé Administrative Assistant — producing standardised company résumés through Word automation.
• Consumer-products client, Maywood, NJ — Gift Sender, using Outlook automation to pre-populate contacts and post selections to the client's website.
• Music publisher, New York, NY — databases to grade, categorise and maintain artists, albums and tracks.

Developer training and consulting firm, Parsippany, NJ · Solutions Developer Consultant · 1999 – 2000

Placed on site with clients following five in-house Microsoft CTEC courses.

• IT services and staffing company — Financial System Package Migration. Data migration from Platinum to Navision, including custom scripts written to extract data from electronic DOS-based reports that standard tooling could not read. The earliest system-replacement data migration in the record.
• IT services and staffing company — Service System Package Migration. Installation of FieldPro with custom export routines carrying data from the older version directly into the newer one, bypassing a multi-step upgrade path.
• Technology-solutions provider, Westport, CT — Meet The Composer Assistant, a front/back-end system for loan and grant applications; and website enhancements including an ASP referral page using a CDO object on Exchange for mail delivery.

---

Accounting and professional services (2009 – present) · Healthcare services (2013 – 2021) · HR technology and FCRA-regulated background screening (2011 – 2014) · Wholesale alarm and life-safety monitoring (2022 – 2023) · Logistics, freight and customs (2006 – 2015) · Consumer-products and watch manufacturing (2024 – 2025) · Insurance and claims (2002 – 2005) · Public sector (state insurance fund, municipal housing authority) · Media and publishing · Retail and e-commerce · Education technology · IT services and staffing.

---

IRIS STAR and accounting-firm operations. Client, engagement and job lifecycle · WIP · billing · invoices · receipts · accounts receivable · allocations and write-offs · realisation · billing rates and rate tables · partner allocations · origination · service lines and service-line groups · due-date management · period close · AR hold and collections policy at 90 days delinquent · progress bills · firm absorptions · engagement and client renumbering · multi-entity and ledger structures · VAT, service-line and job-type cross-references.

What breaks in an IRIS STAR or practice-management migration. Keys change — client renumbering breaks downstream reporting, and a cross-reference table is the cheapest durable fix. Keys do not resolve — in real STAR databases not every ID is guaranteed to link, so extracts should take identifiers from the lookup side rather than the row. Identity drifts between cuts — records change identity between extract phases and only a diff against your own snapshot will find them. Scope is a business decision with a data consequence — cut-off dates strand related records on the wrong side, and inactive-client policy determines what must be archived rather than moved. The same report means different things at different firms — aging is a family of methods, not one calculation, driven by how progress bills are consumed, which is why validating against a firm's own reports is the only honest standard.

Healthcare-services operations. Facilities organised into divisions, regions and districts with territory and destination-zone codes · budgets across housekeeping, food services, maintenance and lease lines with revenue, expense and payroll sections · payroll cycles and company code cycles · staffing grids with par hours and census · budget cut-off dates driven by configuration · calculated budget fields driven by template-default tables · ACA compliance reporting.

Background-screening operations. Order lifecycle across candidate and recruiter surfaces · packages and preselected services · criminal search scope and jurisdiction rules, including multi-county and metro jurisdictions · federal and international searches · adverse action · consent · restricted states · adjudication · DMV, credit, education, employment and social-security-trace verification.

Customs and freight. US Customs AMS messaging in deconsolidator and air-carrier roles · air manifests · EDI · booking of pallet and loose cargo.

---

• STAR SQL SIG (Special Interest Group), sqlsig.com — a monthly technical forum for STAR firms and SQL developers, exchanging practical work on SQL Server, STAR reporting, WIP and AR, automation, integrations, migrations and data warehouses. 133 registered members (live membership database, rechecked 2026-08-24), with 20–30 attending in a typical month. Co-hosted from 2019; restarted and now sole host — he sets the programme, presents most sessions, and fields the questions. Domain purchased and site built personally. Attended by IRIS Software Group staff.
• Recent sessions he presented, each recorded and published with working T-SQL: 2026-07-02 — ten exploratory data-warehouse versions walked through end to end, including the abandoned branch. 2026-08-06 — four working databases and, opening the session, the practice question of how a firm bills for work that AI has made three times faster (1h 27m, multiple firms represented). June 2026 — calling APIs directly from T-SQL on SQL Server 2025.
• IRIS Software Group — working relationships at technical and escalation level, including the Customer Services Team Lead and Technical Consultants for STAR Practice Management, consulted in advance on entity-migration work and engaged on formal escalations.
• Published work — ten exploratory versions of the STAR data warehouse design, each a complete working database answering one design question, published in full with working T-SQL at sqlsig.com; the delivered warehouse went through six further implementation versions, sixteen in all.

---

The Chubb Institute, Parsippany NJ — Computer Programming diploma, 1998–1999.

SetFocus VB Masters Program, 1999 — five certificates: VB6 Fundamentals · VB6 Development · VB6 Enterprise Development · Implementing a Database on SQL Server 7.0 · Web Applications with Visual InterDev 6.0.

Microsoft Certified Professional, 1998–1999 — two of the four examinations required for MCSD.