The Industry I Knew Is Gone
I’m 56 years old, and I’ve been writing software long enough to remember when discipline mattered more than hype. Back then, we argued about architecture, not optics. We wrote documentation because someone else actually had to understand what we built. We followed SOPs not because they were trendy, but because without them, systems broke—and people noticed. I had covered just about every discipline in the industry because I had to in the 90's:
- Developer
- Business Analyst
- Project Manager
- Tester
- Development Manager
- Scrum Master
- Program Manager
- Tech Writer
- Architect
- Tech Support
- Sales Assistance
- Infrastructure and Systems Support
- Networking Analyst
- Database Administrator
- On Call Production Support
I was not someone that could not decide on a discipline and became a jack of all trades, master of none, I had to assume all these roles because the above roles had not yet been fully defined and I was expected to deliver in every example. I was forced to. If you couldn't, you didn't survive. I climbed the career ladder landing me in the Project Management Office as a Program Manager until even that job was diversified and salaries dropped below what an entry level software developer makes today. In the 2020's, I truly thought I could settle back into a developer role as my backup plan and security blanket. I was dead wrong!
My resume had to be paired down from 30+ years experience to just 3. I had to dumb down my resume. I showed up for online interviews when the other party did not show. Not because they were no-shows, but because the recruiter I worked with was dumb as rocks, and simply trying to improve his/her numbers. The interviews that did come through, I was literally asked to show my ID during the interview before it started. Many of these interviews I would show up for, the assumed hiring manager wanted to conduct the interview through chat only. My curiosity got the best of me so I abided by one or two being careful not to provide any personal information. I knew it was fraudulent and was hired immediately with little discussion. But then they they started telling me they would send me a check to purchase my laptop and other devices and that I would reimburse them, I knew the strategy. Even had one of the checks sent to a P.O. box and turned in to any fraud reporting agency I could find. Of course, no response on even that. I literally though I was in the twilight zone and feared for my family and future.
I started getting various contracting jobs to maintain income while I settled back into a technical role, but what I experienced was even more frightening. Jobs that were literally asking for the impossible. Upgrading InfoPath forms for SharePoint when there was literally no viable upgrade path. When I proposed the project to take a year, I was told to stop planning and just move forward with the 2 month timeline given. This was after 2 years at this, prior to my involvement, and no progress. I knew very little about SharePoint and InfoPath but were on my resume from 20 years prior. Another job, when I showed up for work, I asked how to get to the source code and to the servers. Nobody knew other than the 20 year old contract developer that convinced the company to put everything on Azure and with a microservices architecture (one developer). Bottom line, no source code was ever kept in a repo and servers were all over the place from Azure to Amazon web services etc. Nobody knew how to get to any of it and the login/passwords I found and reverse engineered, mind you, had been expired.
Fast forward to today, and I still look around and barely recognize the profession I spent my life in.
Standard Operating Procedures are treated like relics. Mention them, and you’ll get eye rolls or a lecture about “moving fast.” But moving fast toward what? I’ve seen teams sprint straight into walls that would’ve been avoided with a checklist written twenty years ago. Best practices—the hard-earned lessons paid for with outages, lost data, and long nights—are now dismissed as “overhead.”
What’s replaced them isn’t better. It’s louder.
Developers are increasingly siloed inside their own screens. Ask someone how their code interacts with the broader system, and you’ll often get a shrug. It’s not that they’re incapable—it’s that the culture no longer demands that level of understanding. Curiosity used to be a requirement. Now it feels optional. Baby sitting seems to be the appropriate word with working with developers these days. One technology and one area of focus is what they are good at. Ask them to debug beyond a screen into a web service, or into back end stored procedures, and they simply cannot. Regular expressions, never heard of it. It amazes me that developers are hired that don't even know basic debugging skills. "console.log" is the extent to what they know how to do. Keyboard shortcuts, forget it. They instinctively grab the mouse and start clicking around.
What has been thrown out the window due to “lack of demand” are accessibility accommodations: purposely small text, black backgrounds, rampant mispellings. With increasingly worse vision as we age, those things do not seem to matter anymore. Code snippets and SQL statements shared through chat over repository best practices. Everyday is a struggle to maintain sanity as you wonder if you are ready to be put out to pasture, or companies just insist on working in chaos.
And if you do ask questions? Be prepared to be laughed at, or worse, gaslit. I’ve sat in meetings where legitimate concerns were brushed aside with vague reassurances or buzzwords. When something inevitably breaks, the narrative shifts: it was never the plan, or the fault lies somewhere conveniently out of reach.
Even the tools feel like they’re regressing. We spent decades optimizing for efficiency—keyboard-driven workflows, automation, minimizing friction. Now I find myself clicking through bloated interfaces that seem designed for demos rather than daily use. It’s slower, but it looks good in a product video.
Quality has taken a backseat. Unit testing—once a cornerstone of reliable development—is often treated as negotiable. Features are prioritized over defects, even when those defects undermine the very features being shipped. The message is clear: ship now, fix later… or don’t fix it at all.
Support has suffered too. When something breaks, you don’t get expertise—you get links. Articles. Scripts. The burden shifts back to the user, who now has to diagnose and resolve issues the company created. It’s not support; it’s deflection.
Inside teams, there’s a quiet but undeniable pressure to conform to the chaos. Push back, ask for structure, advocate for quality—and you risk being labeled “difficult” or “not a fit.” I’ve seen experienced developers pushed out, not because they couldn’t adapt, but because they refused to abandon standards that once defined professionalism.
Hiring has become its own mess. Candidates exaggerate. Companies misrepresent. Interviews feel less like evaluations and more like negotiations between two sides that don’t fully trust each other. When both sides are playing a game, nobody wins.
Meanwhile, companies go dark on their own customers. Services degrade, outages stretch on, and communication disappears. When responses do come, they’re often defensive—blaming users, environments, or edge cases rather than acknowledging systemic issues.
Even the giants aren’t immune. Massive systems, backed by enormous resources, ship with glaring flaws that linger for years. Fixes are delayed, minimized, or ignored altogether. Accountability feels like an outdated concept.
Underneath it all, the foundation is cracking. Third-party components—the building blocks of modern software—are increasingly unreliable. Updates introduce breaking changes, documentation lags behind reality, and vendors rarely take responsibility. Developers are left stitching together workarounds, hoping nothing collapses under the weight of dependencies they don’t control.
And then there’s the customer divide. Big-money clients get attention, quick fixes, and influence. Smaller customers? They wait. Or they’re told to adapt. Loyalty has been replaced with prioritization tiers.
I’m not naïve. Every generation thinks the next one is doing it wrong. But this feels different. This isn’t evolution—it’s erosion. The principles that made software reliable, maintainable, and trustworthy are being traded for speed, optics, and short-term gains.
I still believe in this craft. I’ve seen what it can be when people care—when teams take pride in what they build, when systems are designed with intention, when users are treated with respect.
But right now, standing here at 56, I don’t just feel outpaced.
I feel like I’m watching something valuable slip away.