Copyright © 2025 D. Etxeverri
All rights reserved.
First Edition
Pull up a stool, order whatever keeps you awake at 2 a.m., and let’s talk about the ghosts that keep our industry interesting. Every business has its legends, but tech is the only one where the ghosts still draw a salary and show up to sprint planning. We keep pitching some glossy future full of AI magic and seamless experiences, but half the time we’re just zip-tying the present so it doesn’t collapse before the next release train. The Ghosts of IT isn’t about banishing anything. It’s about meeting the weird spirits that live in our dashboards, ticket queues, and incident retros, and figuring out why they won’t take a hint.
You’ve met these characters. There’s the SaaS sales rep who pops up every budget season promising a 10x productivity jump if you just sign before quarter end. There’s the executive deck describing a “single pane of glass” experience that would absolutely exist if we had an extra team, an extra quarter, and maybe an extra dimension. And let’s not forget the senior dev who swears the new framework will solve every problem except the four they’re actively ignoring. We opened the door for them with optimistic estimates and neat little “stretch goals.” Now we’re shocked there’s a line of spectral backlog items asking who’s on-call.
This book is for the Gen X folks who still flinch when someone says “portal” and the millennials who inherited agile along with student loan statements. It’s a blend of sarcasm, shop talk, and survival tips because knowing the name of the ghost rattling your servers at 4:52 p.m. on a Friday is half the battle. Think of these chapters as a flashlight for the late-night incident bridge and a reminder that half the “innovation” we sell is held together with hope, duct tape, and a developer who promised they’ll rewrite it “next sprint.”
No inspirational posters here. I’m not going to tell you to “fail fast” (that’s already happening) or to “value outcomes over outputs” (we’ve been doing both since the Blackberry era). What you will find are the stories, shortcuts, and burnt offerings that keep teams shipping when the hype cycle crashes into reality. The ghosts aren’t moving out, so we might as well get on speaking terms, laugh a little, and negotiate better haunting hours.
The SaaS economy is basically a candle-lit séance where a sales team chants about “frictionless experiences” while your finance director watches the subscription bill climb like it’s Space Mountain. Every quarter, a new vendor appears promising to replace three systems, four vendors, and half your headcount if you’ll just sign before the promo ends. The demo is always gorgeous: animated dashboards, predictive charts, and a roadmap full of features that are technically “coming soon” if you squint at the slide long enough. We sign anyway because we’re tired, because the deck looked shiny, or because procurement left the room for five minutes.
The real haunting starts the moment implementation kicks off. “Plug and play” turns into “wire and pray.” Those APIs that looked so tidy on the architecture diagram morph into mischievous spirits, spitting 500s at whoever dared schedule the nightly job. The customer success manager suggests an “adoption workshop,” which is fancy talk for handing out stickers while you rebuild every workflow by hand. Six months later, they’re still telling you this is “within the standard onboarding timeline” while you explain that your business runs on a Lotus Notes relic, three Excel macros, and whatever Carl in accounting coded on a weekend in 2010.
The whole overinflated SaaS bubble stays afloat because we all keep singing along. Investors want recurring revenue, execs want something sexy for the board deck, and your product org dreams of retiring that old monolith that smells like dial-up. So we sprinkle ARR, CAC, and magic AI dust over the conversation like it’s garlic for scope creep. For every tool that actually helps, we adopt three more that promise “AI-powered everything” and deliver another login screen. The alternative is admitting we need to invest in our own stack, which costs money, patience, and doesn’t come with a tote bag.
SaaS isn’t evil, it’s just not a miracle. Best case, it hovers politely and reminds us to rotate our API keys. Worst case, it handcuffs itself to our core process while we’re busy presenting vanity metrics to leadership. The only defense is healthy skepticism. Learn the difference between a partner and a parasite. Ask awkward questions about rate limits, outages, and what happens when pricing “adjusts with value.” And whatever you do, never agree to usage-based billing without a spreadsheet, a lawyer, and maybe a comfort animal.
Automation is our industry’s Ouija board. Everyone gathers around, fingers on the planchette, convinced it’s spelling “profit,” even though it keeps landing on “maybe later.” Auto-generated user interfaces—AUI if you want to sound fancy—are the latest ghost to slide into the conversation. The pitch is always the same: feed the machine some data, toss in a component library, and boom, you’ve got a polished app before lunch. What we usually get is a haunted dollhouse UI with buttons floating in weird corners and forms that forget how validation works whenever Mercury blinks.
Interfaces age like Halloween decorations left out in the rain. Yesterday’s “award-winning redesign” becomes today’s ghosted viewport the second a product manager adds “just a tiny option” to the main flow. Support tickets roll in from users who somehow missed the giant CTA but found the hidden settings link behind a tooltip. We push design systems, pattern libraries, and a group chat called something like #ux-poltergeist-watch, but entropy always slips through. People will mash Enter, misread labels, and drag that modal across the screen just to see if it squeaks.
We keep flirting with AUI because wrestling with layout grids for six platforms is exhausting. You fix the header in desktop, the tablet view breaks. You clean up the mobile nav, someone asks for “just a small chatbot bubble.” Auto-generated screens promise freedom. No more pixel-perfect PRs, no more arguments about whether the button “pops.” Yet every time we surrender creative control, the result looks like a generic template wearing our brand colors like a Halloween costume. Yes, it’s accessible. Yes, the spacing is correct. No, it doesn’t feel like us.
If there’s a cure, it’s memory. Interfaces aren’t one-and-done projects; they’re living scrapbooks of every quick fix and half-remembered requirement. The trick is keeping humans in the loop who know why the chart legend lives on the left or why checkout still uses that cursed teal button. Maybe the reason is “the CEO loved teal in 2009.” Fine. Document it, respect it, and update it on purpose when the time is right. Until then, treat AUI like a helpful intern: great for drafts, but don’t let it ship without adult supervision.
Every company has that mystery server humming under a desk or in a forgotten closet. Legacy systems aren’t just ghosts; they’re ghosts with badges and parking spots. We swear we’ll retire them every budgeting season, yet they keep showing up in payroll and invoicing like nothing happened. The COBOL payroll engine? Haunted but dependable. The inventory database built by an intern in 2002? Possessed by seven stored procedures and a cron job literally named “do_not_delete.pl.” We keep adding shiny new tools around them like we’re renovating a haunted house while ignoring the creepy door in the basement.
When we finally try to pull the plug, we learn the ghost knows our real name: revenue. Flip it off and the company yells. That old ERP might crawl, but it knows every edge case legal ever negotiated. Replatforming isn’t just migrating data; it’s translating decades of late-night hacks, emergency overrides, and hallway agreements. We copy over the happy path, cut over on Sunday, and by Monday morning the warehouse is chasing phantom orders spewing from a job nobody has touched since the Bush era.
The conference talk solution is always “microservices!” or “event-driven!” or “domain storytelling,” like a fancier thesaurus will make the ghost behave. Reality: you need time, patient stakeholders, and a budget that doesn’t vanish after the kickoff deck. Legacy systems stick around because they work the way an old typewriter works—press the keys, ink appears, just don’t ask for emojis. The real danger isn’t the age; it’s pretending the haunt is gone while secretly routing more traffic through it.
If you want to stay sane, treat legacy migrations like campfire stories. Interview the folks who were there. Map the lore. Expect at least one jump scare. Give the ghost a name so when the lights flicker during a deploy, you know which closet to open. And remember: “refactor” and “seance” both require candles, patience, and someone muttering acronyms in the dark.
Frameworks have fan clubs that make comic-con look chill. There’s always a charismatic maintainer on stage swearing that this release—this tiny point update—is the one that finally frees us from boilerplate purgatory. The crowd nods along, wearing limited-edition swag, ready to testify about how migrating from Angular to React to Vue to Svelte to Astro to “something we found on Hacker News” saved their souls and reduced bundle size by a kilobyte. The conversion process usually involves rewriting half the product and quietly phasing out anyone who still speaks fluent jQuery.
We buy in because tech is exhausting and it feels good to belong somewhere. Frameworks ship opinions wrapped in tooling, which is a nice change from leadership’s vague “just be more innovative” chants. The first sprint feels magical: DX dashboards glow, hot reload impresses stakeholders, and the burndown chart actually burns down. Then reality shows up. Business logic oozes into the component tree, the plugin ecosystem mutates into a hydra, and the architect who swore this stack was future-proof takes a new job selling serverless NFTs to enterprises. Congrats, you’re the new high priest of a custom ritual written in TypeScript and hope.
The cultists aren’t bad people—they’re tired. Believing the next abstraction will slay complexity is easier than admitting software is haunted at the source. The framework isn’t the ghost; the expectation that tech can erase trade-offs is the ghost. Gen X devs know this because they dragged applets across the battlefield. Millennials know it because they watched grunt turn into gulp turn into webpack turn into a 600-line Config of Holding. The trick is practicing spiritual tolerance. Let teams experiment, but demand documentation of their theology. No more hidden altars in the build pipeline.
When a framework zealot corners you at happy hour, offer empathy and maybe a pretzel. Ask about upgrade plans, migration paths, and who’s on pager duty when the core team goes radio silent. Share whatever snacks HR left in the kitchen. Most importantly, remember the holiest framework is the one somebody else will maintain at 3 a.m. If their cult evaporates the moment an incident hits, it’s not a faith—it’s a book club with better stickers.
Tech marketing loves to pretend the code is haunted, but the real ghosts are the unspoken deals between people. Team dynamics decide whether a project ships or becomes another cautionary tale. Those cross-functional slides with smiling avatars? In real life it’s product, design, and engineering bargaining like rival bands sharing one drum kit. Stand-ups turn into confessionals. Sprint reviews feel like séances where stakeholders ask the roadmap to conjure features out of thin air. The folks chanting “one team, one dream” are often the same ones firing off escalation emails at 11:59 p.m.
Gen X managers and millennial leads carry a special set of hauntings. They’re expected to be empathetic coaches, hard-nosed delivery drivers, and part-time therapists for everyone’s burnout. They lived through waterfall, agile, DevOps, DevSecOps, and whatever buzzword HR is piloting this quarter. They know morale can nosedive because someone merged without testing or because a VP dropped “quick question” in Slack. We’re told to “bring our whole selves to work,” which sounds warm until your whole self includes impostor syndrome, medical bills, and the steady dread that “MVP” now stands for “Maybe Victory, Possibly.”
Good teams build ghost traps. They create space to say “this service is on fire” without someone offering a mindfulness webinar. They celebrate removing code as much as shipping it. They keep stakeholders from hijacking planning with drive-by requests. Sarcasm stays playful, not poisonous. When the drama spikes, a decent tech lead knows the difference between a noisy Slack thread and an actual outage. They know when to escalate, when to shield the team, and when to admit the request is impossible—but still sketch out the options because that’s the job.
The tools get all the press, but culture is the foundation. Protect it and you can survive cursed releases, must-ship deadlines, and the occasional all-hands meltdown. Ignore it and the ghosts will organize in your group chats, scheduling meetings that suck the joy out of the room faster than an unsized Jira epic.
Designers can paint a future so pretty you forget the printers are on strike. In the kickoff room, we’re passing around mood boards like they’re concert flyers. There’s a cinematic walkthrough, a manifesto about “delighting the user,” and a statement about “launching with a north star experience.” Meanwhile the engineers in the corner are calculating how many feature flags it’ll take to ship anything by quarter’s end. We promise the board a “unified platform” and then realize half of what’s in the deck is vaporware held together by a prototype demo and the word “aspirational.”
Real implementation looks less like a Dribbble shot and more like a crime scene: Jira tickets taped everywhere, developers triaging API timeouts, designers redlining components because the Android build shifted one pixel. We run design critiques by day and bug bashes by night. The marketing site claims the feature is live worldwide; reality says it’s in limited beta with a kill switch. Somewhere in the chaos, senior designers are translating the dreamy pitch into something an engineer can actually merge. They’re rebuilding the design system, writing real documentation, and reminding everyone that gradients don’t ship, stable services do.
It’s not that vision is bad; it’s that vision without execution becomes haunted merch. The ghost on every roadmap is the gap between how we sell the story and how we build the thing. The only cure is keeping design close to the code. Invite the dreamers to standups, invite the engineers to critiques, and admit when a slide is pure wish-casting. The picture matters, but the merge button is where the lights stay on.
Tech loves the stereotype of the brilliant but awkward genius—the hoodie-wearing savant who can debug anything but can’t make eye contact. A lot of us leaned into it because, frankly, it was easier than practicing small talk. We skipped sports, ghosted office happy hours, and let the myth be our personality. When forced into social settings, we’d rather dissect keyboard switches than discuss literally anything on ESPN. Ask about dating and we default to deployment metaphors. It’s funny until you realize half the team treats collaboration like an optional DLC.
The thing is, being great at tech doesn’t excuse staying emotionally twelve forever. The best engineers I know can pair with juniors, talk to legal, and still grab lunch with marketing without breaking into hives. Nerdiness is a superpower when it’s paired with basic human skills. When it’s not, you get haunted meetings where nobody takes ownership because everyone is hiding behind GitHub handles. The ghosts here are the social gaps nobody wants to close: the teammate who never turns their camera on, the architect who writes manifestos but never gives feedback, the manager who avoids conflict until production does it for them.
If we want healthier teams, we need to retire the savant myth like an outdated API. Encourage folks to learn improv, lift weights, join the office bowling league—anything that teaches timing, empathy, and how to lose without rage-quitting. Being technical is table stakes. Being human is what keeps the hauntings to a minimum.
Ask any senior engineer what their “dream job” is after a rough sprint and half will mumble something about NASA. Not the actual NASA that wrestles with procurement paperwork and 40-year-old flight software—the Hollywood NASA with dramatic lighting and inspirational monologues. It’s the ultimate escape fantasy: ditch the ad tech hamster wheel, work on rockets, maybe cry in zero gravity. Never mind that the real space agency feels like a cousin of your local DMV with better acronyms.
We chase these fantasies because corporate roadmaps can feel like Groundhog Day. Maybe it’s NASA, maybe it’s the startup building underwater drones, maybe it’s opening a vinyl shop. Anything sounds better than refactoring the billing service again. But ghosts follow you. Space agencies ship PowerPoints. Defense contractors burn out teams. That indie studio? Turns out “creative freedom” also means “no QA, good luck.” The hauntings don’t stop; they just change uniforms.
Dream big, sure. Apply to NASA if it makes you happy. Just don’t pretend the gig will magically cure the culture issues we carry around. Anywhere you go you’ll still be syncing Jira, arguing about OKRs, and trying to explain to your parents what you actually do all day. Space might look glamorous, but it’s still a conference call with better props.
The hauntings we deal with aren’t new; they’re reruns from the dial-up era. Ask a Gen X engineer about the dot-com boom and watch their eyes glaze over like they’ve seen the future and it’s powered by Pets.com. There were IPOs for companies with no revenue, office parties with lava lamps, and back-end stacks held together by ColdFusion and optimism. When it all crashed, the ghosts stuck around. Now every hype cycle feels like a remix—crypto NFTs, metaverse malls, AI that promises to replace interns but still can’t format a spreadsheet.
The common thread? Overpromise, underdocument, and hope nobody notices the duct tape. The dot-com ghosts taught us to launch betas that never graduate, to worship vanity metrics, and to outsource common sense to consultants. They whisper in leadership’s ear, convincing them that this time is different because we added “machine learning” and a new font. Meanwhile, engineers keep rediscovering why batch jobs run at midnight and why “scale fast” means “triple your pager rotation.”
Knowing the history helps. Once you’ve survived a bubble pop, you start spotting ghostly patterns—executives who talk like motivational posters, investors who confuse DAUs with value, marketing teams who ship merch before specs. Call it out. Archive the lore. Remind the juniors that haunted tech is still tech, and the best thing we can do is build with honesty and leave breadcrumbs for the next team who stumbles into the basement.
Here’s a fun drinking game: compare a company’s valuation to the amount of working code they ship. Spoiler, the math doesn’t add up. We brag about unicorn status while the core product still behaves like a beta. Investors toss around nine-digit numbers for platforms that are basically a slightly fancier spreadsheet. Meanwhile, engineers quietly calculate the cost per line of code that actually runs in production and wonder why they’re debugging stock-based comp in their spare time.
Every release has hidden price tags. That bug fix took three engineers, a designer, and a PM—plus the QA hours, the staging environment, the Slack threads. If you translated it to dollars, half of our “velocity” would look like a luxury purchase. Senior designers know this because they spend their days covering for kindergarten-level asset dumps. Junior designers hand off Figma files with drop shadows imported from dreams; seniors translate them into color tokens, accessibility checks, and assets that won’t crash the Android build. On the engineering side, staff engineers babysit half-baked features until they’re stable enough to show leadership without lighting the roadmap on fire.
None of this means we stop chasing big valuations. It just means we acknowledge the ghosts in the ledger. If we priced the code that actually ships, there’d be no room for fantasy hockey valuations. The antidote is transparency: track what it costs to deliver, celebrate the boring wins, and reward the people turning kindergarten sketches into production gold. Until then, cheers to the teams making usable software while the market pretends vibes equal EBITDA.
The ghosts of IT aren’t evil; they’re reminders that progress is messy and attention spans are short. We daydream about a future where systems hum in harmony, data is clean, users follow tutorials, and the QBR doesn’t sound like a pitch for magic beans. That dream is about as likely as a serverless blockchain metaverse backed by COBOL. What we can actually get is a peace treaty: admit the hauntings, dial down the marketing fairy dust, and build systems that expect chaos instead of pretending everything will stay tidy.
Maybe the SaaS bubble soft-lands. Maybe AUI stops spitting out uncanny mockups. Maybe the next interface trend cares more about people than hype. Or maybe we keep inviting new ghosts in and learning to laugh at the comment history they leave behind. Either way, the industry keeps moving because people keep showing up—late nights, cold pizza, meme-filled chats—patching holes and writing the documentation later if we’re lucky. We’re not chasing perfection anymore; we’re chasing resilience with a smirk and a backlog.
So grab your flashlight, your monitoring dashboard, and that cursed playlist you save for midnight deploys. The ghosts aren’t leaving, and honestly, neither are we. If we’re going to be haunted, we might as well make the bar tab worth it.