



I've made a few transitions back-and-forth from companies that develop in Java and C#. Technically, there's really little difference for Internet companies. You can in fact, create functioning high performance systems in either environment. Development is similar, tools are similar, performance is similar. Both languages fit in the just-in-time compiled type environments which is a sweet spot for web development (sitting somewhere in the middle of compiled languages like C++ and dynamic, interpreted languages like Ruby).

My latest transition was from LinkedIn (mostly a Java environment) to Lending Tree (mostly a C# environment). What struck me about the transition this time was not actually something new to me, but I think I saw it in a new light.

In Silicon Valley, we were Software Engineers. In Microsoft shops, we were Software Developers. Again, this may solely be anecdotal of my experience, but that experience did have me considering those titles more closely.

I thought about the nuances of what those titles imply. Not so much of the proper definitions, but what they meant to me. To complete the picture, you need to examine the entire technical ladder. Both Google and LinkedIn follow something akin to Software Engineer, Senior (Software) Engineer, Staff Engineer, Senior Staff Engineer, Principal Engineer. In companies with "developer" ladders, its was something like: Software Developer, Senior (Software) Developer, Architect, Senior Architect.

Personally, I didn't quite get the leap to Architect. To me, every creator of software not only develops it, they design, architect, and build it. More junior engineers tend to architect things with smaller scope and more senior engineers tend to architect with larger scope. However, at all levels they still wrote code and decided on its organization.

Titles are always approximations as most everyone wears more than one hat, but titles do specify an intent. Software developers and engineers did not do anything notably different in their day-to-day jobs, especially at web-based companies. So the name difference really came down to perception. The word "engineer" to me did convey some responsibility on the title holder that they engineered software. They designed it, architected it, and built it - at every level. Developers obviously developed it.

The Engineering ladder (ala Google and LinkedIn) also had the advantage of continuity. That continuity promoted a strong sense of ability to grow within an organizations technical ladder. If a company is intent on building a world-class engineering organization, it's paramount they provide a technical ladder that provides a real career path through engineering. One that conveys progression of (at a minimum), responsibility, accomplishment, reward, compensation, and respect.

I recall at Google that it was important to enter the company at the right title. You didn't want to start at a title you weren't ready for because you'd likely receive a sub-par performance review out of the gate. They would and do reduce your title if a mismatch became evident. The title truly followed the ability. You didn't earn a title - you earned the technical ability and stature that was indicative of a title. The title itself simply followed along.

Similarly, when you received a promotion up the technical ladder you were probably getting used to excellent performance reviews. After all, you were getting a promotion. After the promotion however, you should be ready to potentially receive more mediocre reviews. You're doing the same or better work, but the expectations of your position have been raised. Your new title expects more.

I joined Lending Tree a few months ago which historically followed the "developer" track. Right away I started exploring how people felt about their software titles and careers. After gathering a lot of data and talking to a lot of people, I made my case and we made the change.

We changed titles from developers/architects - to engineers. The entire engineering department, all at once.

Software and Senior Developers became Software and Senior Engineers. Architects and Senior Architects became Staff Engineers and Senior Staff Engineers. We created a technical ladder that defined concretely what those titles meant. What was expected of anyone in those positions with a road-map for advancement. Employee performance is composed of many things but the requirements of your title on the ladder is a big component.

So far I'm thrilled with the results. Everyone at a minimum has expressed a greater understanding of what is expected of them. Every engineer on our team is expected to design, architect, and code software.

Our titles are not language specific either. We're engineers of software. Most of systems were written in C# but we also use Java, Python, and Javascript. We choose the best technical solution (with an eye toward business constraints) however it presents itself. (We push the envelope too, I'm extremely excited to say that our first C# application running in .NET core in a docker container in Linux went into production last month!)

We're not software developers and architects anymore - we're Software Engineers. Different specialties, different skill levels, different technical experiences - but we're here with one mission to build the best software and systems we can for our customers.

(And of course - we're hiring. Lending Tree is a top-10 accelerator on Forbes list of Fastest-Growing Companies. We're looking for C#, Java, and Javascript engineers of all levels at our HQ in Charlotte. We'll consider remote work for the right applicant. Email me at jobs@lendingtree.com)



