Twenty-eight years is a long time.
Long enough to watch technologies come and go. Long enough to see systems that once felt permanent eventually replaced by something better. Long enough to work through major changes in customers, products, teams, architecture, and the way software itself gets built.
And, most importantly, long enough to build relationships with people who become a meaningful part of your life.
After 28 years at Concord, I am moving on.
That is a simple sentence to write, but it represents a very large chapter of my career.
A Career Measured in More Than Years
When you spend this much time with one organization, it is difficult to separate your professional growth from the history of the company itself.
Over the years, I have had opportunities to work across software development, architecture, infrastructure, security, operations, product delivery, and engineering leadership. I have been fortunate to help build systems, modernize platforms, solve difficult production problems, improve engineering practices, and work alongside people who cared deeply about getting things right.
Some of the technology we considered modern early in my career would look almost unrecognizable to developers entering the industry today.
The tools changed.
The architectures changed.
The expectations changed.
But many of the hardest parts of building software never really did.
Understanding the real problem.
Making good decisions with incomplete information.
Building systems that can survive production.
Balancing technical quality with business reality.
Helping teams become better than the sum of the individuals on them.
And learning, usually the hard way, that the most interesting engineering problems are rarely just engineering problems.
The Work Matters. The People Matter More.
Looking back, I remember plenty of projects, releases, incidents, migrations, redesigns, and technical decisions.
But those are not the things that stand out the most.
I think about the people I worked beside.
People who taught me things.
People I had the opportunity to mentor.
People who challenged my assumptions.
People who stepped up when something broke late at night.
People who cared about customers and teammates when it would have been easier not to.
Engineering careers are often described in terms of technologies and accomplishments, but very little meaningful software is built alone.
Whatever impact I had during my time at Concord was made possible by the teams around me.
For that, I am deeply grateful.
Some of the Things You Remember
Not all of the memories are about projects, architecture, or releases.
Some of them involve a pager.
There was a time when supporting production occasionally meant physically driving to the data center. If something needed attention, there was no logging in from a laptop at the kitchen table. Sometimes you had to go there.
And sometimes, I already had my family with me.
More than once, my family found themselves making an unexpected trip to the data center with me after I promised that it would “only take a few minutes.”
It rarely did.
I can still picture my son and daughter waiting impatiently while I worked, finding ways to entertain themselves around me and the rows of server cabinets while I tried to get whatever had gone wrong working again.
Those nights probably felt a little less amusing to them at the time than they do looking back now.
There is another coincidence that has always made it easy for me to remember just how long I have been at Concord: my daughter was born one month before I joined the company.
In a very real way, I can measure my time at Concord alongside watching my children grow up.
That makes 28 years feel less like a number on a résumé and much more like a substantial part of our family history.
My career inevitably asked things of my family too: interrupted evenings, after-hours calls, pager alerts, unexpected trips to the data center, and plenty of instances where “a few minutes” turned into something considerably longer.
So one of the most important thank-yous in this article belongs to them.
Thank you for supporting me through all of it, for being patient when work interrupted life, and even for those memorable family nights at the data center.
I certainly did not build this 28-year career alone.
Twenty-Eight Years of Change
One of the most interesting parts of a long career in technology is seeing how dramatically the industry evolves.
I have watched development move through generations of tools, languages, platforms, deployment models, and architectural styles.
We moved from physical infrastructure toward virtualization and cloud services.
From manual deployments toward automation and continuous delivery.
From tightly coupled systems toward APIs, services, containers, and distributed architectures.
Security evolved from something often addressed late in the process to something that must be designed into systems from the beginning.
And now artificial intelligence is beginning to change how software itself is designed and built.
Every generation of technology arrives with promises that the previous generation’s problems are finally solved.
They never are.
The problems simply move.
That has probably been one of the most useful lessons of my career.
There is no final architecture.
There is no perfect technology stack.
There is only the best decision you can make for the problem, the organization, and the moment you are in.
What I Am Taking With Me
A career this long leaves you with plenty of lessons, but a few stand above the rest.
Technology is temporary. Judgment compounds.
Knowing a particular framework is useful. Knowing how to evaluate a framework is far more valuable.
Simple systems age better than clever ones.
Complexity always sends an invoice eventually.
Production is the ultimate code review.
A design can look perfect on a whiteboard and still fail the moment real users, real data, and real operational constraints arrive.
Strong engineering cultures are built deliberately.
They come from expectations, habits, trust, accountability, mentoring, and thousands of small decisions made consistently over time.
Leadership changes what success looks like.
Earlier in a career, success often means solving the difficult problem yourself. Later, success increasingly means creating an environment where other people can solve problems you may never personally touch.
That transition has been one of the most rewarding parts of my career.
Closing One Chapter
There is always some uncertainty when a chapter this significant ends.
There is also opportunity.
I am proud of what I contributed during my time at Concord. I am grateful for the opportunities I was given, the problems I was trusted to solve, and the people I was fortunate enough to work with.
There are too many individuals who influenced my career to name without inevitably leaving someone important out.
So I will simply say thank you.
To everyone I worked with over these 28 years: thank you for the conversations, the debates, the late nights, the successes, the failures, the lessons, and the friendships.
They mattered.
And they still do.
What Comes Next
For the first time in a very long time, the answer to that question is not completely defined.
I am comfortable with that.
Software engineering is entering another fascinating period of change. AI-assisted development, agent-based systems, increasingly capable automation, modern cloud platforms, and new approaches to software architecture are creating opportunities that would have sounded like science fiction during the early years of my career.
I still enjoy building things.
I still enjoy solving difficult problems.
I still enjoy helping engineering teams improve.
And I am still curious about what comes next.
Twenty-eight years at one company is an ending worth reflecting on.
But it is not the end of the story.
It is simply time to start the next chapter.
What I’m Building Now
A few of the projects I’m currently working on:
- Copy GitHub Repo — a PowerShell tool for creating clean repository snapshots without carrying forward Git history.
- AI Flywheel Specification — an evolving specification focused on making AI-assisted software development more structured, repeatable, and effective.