It occurred to me over the summer that I missed a significant milestone:  As of May 2020, I had been working in IT and technology for 30 years.  That started with my college graduation in May 1990.  Certainly time flies.  In that time, I’ve worked for exactly two companies (Marathon Oil Company and Microsoft).  If CEOs and VIPs can write books on their stories, I can at least write a blog post on mine.  (One of these days, I’ll tell some of the more interesting stories that happened along the way.)

The pre-history

To tell my 30-year story, I need to go back to well before May 1990 when I got my first “real” job – all the way back to the 70’s to be exact.  Fifth grade.  I made a trip to my hometown high school where I got to use a computer for the first time.  It was a PDP-11 running RSTS/E v6c – it wasn’t at the school but rather was connected through a multiplexor modem, 1200bps shared between four devices.  Why do I remember the OS name and version?  Because every time you would sign in, it would print that on the screen, slowly.  And if you used a DECwriter, it had a certain rhythm to it when typing out those characters.  But the whole setup was good enough to write code, using the built-in BASIC interpreter.  My first programming.

Over the years I spent a lot of time in the high school computer lab.  After school, the high school principal would give me his master keys and I’d let myself in.  The equipment expanded from just those first few terminals to also add Commodore SuperPET devices, all wired together so they could share a floppy drive and a daisy wheel printer, useful to learn FORTRAN (not too bad) and COBOL (ick), and then Apple II computers.  I spent a lot of time “playing” with all of them, and eventually taking classes in high school.

Needless to say, there was little doubt about what I wanted to study when I went to collect: computer science.  College was expensive (well, if you don’t compare it against the costs now) so I only considered in-state public universities, eventually deciding on Ball State University because they were willing to give me a scholarship that paid a significant percentage of the (cheap) tuition.  It was a fine undergraduate program that taught me a lot about programming, programming languages, and even some on the absurdities of business requirements (e.g. a senior group project where I wrote a scheduling system that required implementing a shortest path algorithm in a programming language, dBase III, that didn’t support arrays and could only handle 255 total variables in memory at once).  But more importantly, it allowed me access to a lot of computers – VAX/VMS, BSD, Macs, PCs, etc.  College isn’t just a place to be taught, it’s a place to take advantage of the opportunities to teach yourself.

I worked an assortment of jobs while in college – summer jobs in a furniture factory building hotel furniture (still have flashbacks and a weird obsession with opening up the drawers of the furniture of every hotel room I stay in to see who made the furniture), university jobs working with the computer labs, and one other job that stood out:  I was an Apple student rep, helping the university and students at the university with their Mac needs (since that’s all Apple made at that point). 

Time to get a real job

After college, it was time to find a job.  In typical imposter syndrome style, I didn’t think I was good enough for the Silicon Valley startups and well-known ISVs, so I looked at corporate IT jobs in the general vicinity.  I interviewed at multiple companies, including a pharma company in Evansville, IN; a healthcare company in Louisville, KY; an oil company in Findlay, OH, etc.  Without really knowing what I was getting myself into (although I did tell each company that if they expected me to write COBOL, they’re looking at the wrong person), I went with the highest bidder:  Marathon Oil Company.  I started there in May 1990, days after graduation, borrowing a car and apartment/utility deposit money from my parents because I was broke.  I remember buying groceries from the local Kroger store on my credit card (because in the 80’s any college student could get a credit card without any co-signer – not sure who ever thought that was a good idea), sleeping on the floor of my apartment because I hadn’t yet bought a bed, waiting for a paycheck.  A joyous time.

Interestingly I expected to become a mainframe developer there, but on my first day I found out that I had been chosen to become a mainframe DBA.  (I later asked my boss why I was chosen.  “I chose all the CS majors, not the MIS majors.”)  I joined a team of about 10 people, and was paired up with another young DBA who defined our mission:  To automate ourselves out of that job and into things more interesting.  And we did a lot of automating – skills that were surprisingly useful later in my career.  Eventually that job shifted into systems programming (I am a pro at S/390 assembler).  But the real change came in 1995, with the growth of PCs:  the company needed those PCs to emulate a mainframe terminal, so I got assigned to a project to choose an emulator and get the setup implemented.  Within a few weeks, it was decided to put TCP/IP on the mainframe and use one of many available TN3270 emulators.  Project done.  (Thank goodness, I could have spent years battling OS/2 or SNA Server.)  But the PC team still had my services for months after that, so I got put to work on PC management, working on learning and implementing Systems Management Server 1.2 to do Program Group Control for running apps from a NetWare server.  Ugh, what a mess.  But I never went back to the mainframe, and instead focused on bringing that mainframe “control” to PCs.

The NetWare servers were eventually replaced with Windows NT 3.51 and Active Directory, SMS 1.2 was replaced by SMS 2.0, Program Group Control was killed off (thankfully), Windows 95 was deployed (through the fun of Y2K), and PCs took over.  But it was still chaotic.  By the end of the century, we were looking to do a “big bang” replacement of all the devices in the company at once – moving to Windows 2000, building a software delivery system on top of SMS 2.0, standardizing the infrastructure for PCs worldwide (and traveling all over to do that).  It was groundbreaking work at the time, and it worked well – mostly.  For those who don’t remember SMS 2.0, it would break down frequently.  And it usually wasn’t even worth troubleshooting the problem, just reboot the server and the problem will likely go away.  By the time Microsoft started working on the next version of SMS, eventually released as SMS 2003, we enthusiastically volunteered to be a TAP customer – we were determined to make Microsoft improve SMS, mainly for our own sanity.  That started me down the path to work for Microsoft.

This same time also got me started in the SMS community, through mailing lists and blogging, and even presenting in front of large crowds at industry conferences – a terrifying prospect for me at the time (and even today I would say there’s still a certain amount of terror involved – I’ve just gotten more used to it).

All total:  14 years working for employer #1.  Like many people there, I joined thinking “five years and out” (vesting in the retirement program – something that really doesn’t exist any more), and before I knew it 14 years had past.

Joining Microsoft

I had initially reached out to Microsoft after attending the launch event for SMS 2003 at an event in Copenhagen – and didn’t hear back.  I then reached out to recruiters working for Microsoft that had hired other community members.  They initially offered me an interview for a consulting job doing systems management (i.e. SMS), but before that interview happened they said they already hired someone for that job, how about a different job that does OS deployment?  Sure, no problem – but then I had just a few days to learn everything I could about OS deployment.  Sure, I was working closely with the team that did that at Marathon, but I wasn’t doing it myself.  They probably wondered why I suddenly had such an interest.  But my crash course was successful, I got offered the job on the drive back from the airport (flying back home to Houston after the interview) and accepted it on the spot.

Ironically, I got a call less than 15 minutes later from Microsoft again, but this time in regards to a PM job on the SMS team.  I politely told them that they were too late, I already accepted a job with Microsoft Consulting (MCS).  I started at Microsoft in January 2004, working on a team that specialized in OS deployment, pushing to get customers moved to Windows XP.  (Equally ironically:  I was an Apple fanboy, proud that I had never spent a cent on Microsoft software before joining Microsoft.)

After a short time working with MCS (including another terrifying presentation to 800 people about how Windows XP SP2 was a good thing, even though you had to effectively redeploy the OS), I was sent to the middle east to work with a customer there (a unique experience).  While there, I got a widely-broadcast e-mail looking for help supporting beta customers for the Business Desktop Deployment (BDD) 2.0 release.  I volunteered, and was interviewed by the team in the middle of the night (middle-eastern time – nothing like setting an alarm for 3am to make a phone call), and was offered the role.  I started working on supporting beta customers (one in Sweden, one in Chile, one in Toronto, a few in the US – there were some serious frequent flyer miles involved), but “others” were doing the development work – at least until they weren’t.  One other MCS consultant got pulled off to work on a different project (the only person actively coding on the project), leaving no one to write the code.  So, overnight I stepped in to become the developer.  That role continued through the release of BDD 2.0 (at MCS rates – the solution accelerator team was paying MCS for my time), and afterwards I was back to consulting with “normal” customers on OS deployment projects.  With small children at home, the travel (probably 80% of the time) got to be a bit much, so I started looking at jobs in Redmond again.  And again, that took me to the SMS team, where I was interviewed for two different jobs at once:  One that sounded great (PM focused on the tech) and one that sounded like torture (PM focused on partner agreements).  But in a weirdness that is probably unique to Microsoft, someone on the interview loop said no (probably those who wanted to hire a person for the torture job), so again I didn’t join the team.

But the team I worked with on BDD previously, the Solution Accelerator team, was just across the street, so since I was in Redmond anyway I stopped by to say hi – and was offered a job on the spot.  They didn’t know I was interested in relocating (and it was cheaper to hire me than to pay MCS for my time).  So fairly quickly I relocated and BDD, which later became MDT, was a full-time job.

The work on BDD/MDT went through several releases combined with lots of customer presentations, calls, and visits, working with a small team of developers, a large team of testers (back when that was a thing), and a large documentation team (back when that was a thing).  That lasted for eight years, with lots of customer presentations, blogging, and social media involvement.  That involved lots of work with the Windows product management/marketing team, so when it became time for a change (a subject to be discussed at a bar somewhere, even though I don’t drink), I went to work for that team – spending even more time presenting to customers, blogging (including ghost-writing a lot of Windows blog posts, beyond just my own), and working on social media. 

That eventually led me to Windows Autopilot, building the marketing plan for the feature and working with the team on the original release.  (How many marketing people do you know that write PowerShell scripts?  The Get-WindowsAutopilotInfo script was written while I was still in marketing.)  After a while I decided to switch back to a more technical role and joined the Autopilot team as a PM.  A few months after I started, a Microsoft reorg caused the entire team to become part of the same team that owns Configuration Manager (formerly SMS) and Intune.  Another irony, that after multiple attempts trying to get a job with that team, I was reorg’d to become part of it.

Time flies, it’s been 2.5 years working as a PM on the Autopilot team, and in that time Windows Autopilot has grown from an initial concept (a simplified way to provision new devices without imaging and driver management, where users can set up the device themselves without any IT touch) to something that has been used to provision millions of devices (so far).

All total:  16+ years working for employer #2.

Here’s to many more years

Certainly I’m not done yet – I think I’ve got at least another 15 years left in me (and I’m not really sure I’ll ever really want to retire).  With any luck, the coming years will be just as interesting as the last 30 have been.