Case study
Legacy batch jobs to SQL pipelines
Moving COBOL-era batch processing toward observable, idempotent ETL while keeping the remaining mainframe work in view.
Open case study ↗Work / Ledger systems and data pipelines
Nearly five years in BCA’s General Ledger team, working across journal workflows, legacy batch processing, ETL, reporting, and production operations as my role grew from learning the system to owning and modernizing parts of it.
I spent nearly five years around BCA’s General Ledger systems, first as an intern and later as a software engineer. The work sat across journal processing, batch jobs, reporting and data flows, year-end operations, production support, and the internal applications used to keep those processes running.
Much of the job required understanding how a financial process moved through several systems before deciding where a change actually belonged.
My early work was closely tied to the operational side of General Ledger: journal workflows, recurring batch processes, reporting flows, simulations, and the procedures surrounding year-end closing.
That meant learning more than the code. A single process could depend on legacy programs, database jobs, schedules, downstream systems, manual procedures, and business rules that had accumulated over time.
Production support and year-end simulations became an important part of that learning. Debugging often meant tracing a problem across those boundaries, understanding what the expected accounting behavior was, and working with other teams or users to determine where it had diverged.
As I became more familiar with the environment, my work became less about following an established procedure and more about figuring out what needed to change.
I increasingly worked directly with users and adjacent teams, traced existing behavior myself, broke larger problems into implementation work, and followed changes through testing and operational use.
The work ranged from journal and reporting changes to cross-system data flows and production issues. What connected them was the need to understand the process end to end rather than treat each request as an isolated code change.
One of the larger threads during this period was moving parts of the existing batch estate toward SQL- and ETL-based processing.
The work usually started with understanding what an existing job actually did: its inputs, transformations, dependencies, scheduling, outputs, and the systems that consumed them. From there, selected processing could be rebuilt in a form that was easier to operate and evolve while preserving the behavior the surrounding accounting process depended on.
The migration was incremental rather than a wholesale rewrite. Newer processing had to coexist with legacy paths, fit existing schedules, and be validated against the operational procedures already in place.
Go deeper: Legacy batch jobs to SQL pipelines → case study
Not every improvement required replacing a legacy system.
Some of the larger pieces of work came from recurring operational friction. One example was an internal, metadata-driven system for managing report parameters, which grew to include locking, versioning, audit history, approval flows, and a later architectural revamp.
Other work automated parts of journal testing and recurring operational procedures that had previously required several manual steps.
These projects were useful for a different reason: by that point I was no longer only changing the systems that performed the financial processing. I was also building tools around the people who had to configure, test, and operate them.
Over time, part of my responsibility became helping other engineers understand the environment I had spent years learning.
I documented process flows, data mappings, troubleshooting procedures, and migration knowledge, and helped teammates navigate the mainframe and General Ledger processes behind the applications they were working on.
That progression—from learning an unfamiliar operational system, to changing and modernizing it, to being able to explain it to someone else—is probably the clearest way to describe how my role developed at BCA.
BCA taught me that understanding a system often requires understanding much more than its code.
Behavior can be distributed across programs, data flows, schedules, operational procedures, business rules, and the people who know why those pieces exist. Changing one part safely starts with tracing that larger path.
That way of working stayed with me: understand the process first, find the actual boundary of the problem, and only then decide what should change.
02 / Go deeper
Artifacts owned by this role, with the problems, systems, and decisions they explore in more detail.
Case study
Moving COBOL-era batch processing toward observable, idempotent ETL while keeping the remaining mainframe work in view.
Open case study ↗Case study
A metadata-driven internal dashboard that made report-parameter changes safer, more auditable, and easier to evolve across more than 150 reports.
Open case study ↗Sketch
A system-design sketch showing how a client obtains an authorization code and exchanges it for an access token before reading protected API data.
Open sketch ↗Atlas context
See how this role connects to the projects, case studies, notes, and ideas around it.