Journey to junior

Alternative paths into software development

There’s a real shortage of the right kind of talent out there, and innovative new approaches can be a great way to tackle this problem. Over the past 10 years at Haeger Consulting, we’ve poured time and resources into building a trainee program aimed at bringing lateral entrants, career changers, and newcomers into Java software development – and we’ve seen some amazing success stories along the way. “So, how exactly do you do it?” is one of the many questions we get asked.

So, how do we do it?

A Quick Historical Overview

The trainee program we know today didn’t just appear overnight—it evolved through hard work. It all started with me making the switch into the Java ecosystem. I came from a Delphi/.NET background, and what I’d done before could only generously be called “professional software development.” So, I wasn’t completely out of my element or a lateral entrant in the traditional sense; I was more of a career changer. But when it came to Java, I was as far removed as the Earth is from the sun. One day, I went for an interview with my current boss, Ralf, and got thoroughly grilled by an employee (employee number 1, who’s still with us today). After the interview, as we were saying goodbye, Ralf asked, “So, can Andreas do anything?” The answer was as blunt as it was crushing: “Nothing we need.” Then Ralf asked, “But do you think he can learn?” “Probably,” was the reply—and that was my green light to start teaching myself everything. I managed pretty well, and after a year I was asked, “Andreas, would you like to mentor a trainee for a few months and teach them Java?” Of course, I couldn’t say no—and that’s how our trainee program was born. In hindsight, it all seems so well planned.

Who We’re Looking For

But what kind of lateral entrants, career changers, or newcomers are we after? What qualities should they have? Over the years, we’ve come to a bold conclusion: about 95% of people just aren’t cut out for quickly breaking into IT (a hard lesson learned from trainees who didn’t make it). So, we focus on finding that other 5% and equipping them to be ready for their first Java project in a reasonable amount of time. Here are the essential qualities we look for:

CURIOSITY
As a beginner, you need to be curious about the field you’re entering. You want to understand how things work—how software and software development tick. It helps to have that “seek out new lifeforms and new civilizations” mindset.

GRIT
You need the determination to really dive into a topic. This isn’t about stubbornly sticking with something that isn’t working; if you hit a dead end, you should be able to let go, take a step back, come up with a new plan, and try again.

MOTIVATION
There has to be something that drives you. Ideally, you’re excited by the idea of developing software. Just writing a doubly-linked list in Turbo Pascal back in school isn’t enough—you should have already played around with a programming language or even a framework.

INDEPENDENCE
Being able to work independently is key. You must be capable of learning new things on your own (of course, with some guidance) and then proactively continuing the work. Waiting around for instructions won’t get you far.

TEACHABILITY
It doesn’t help if you react badly to criticism. You need to be open to feedback and willing to act on it.

ANALYTICAL AND ABSTRACT THINKING
This is a classic requirement you see in nearly every software developer job posting. For our trainee program, being able to think both analytically and abstractly is essential.

COMMUNICATION SKILLS
It’s important to be able to express yourself clearly. You’ll always be interacting with colleagues, managers, clients, and so on, so good communication is a must.

COURAGE
Last but not least, courage. Perhaps the most important quality of all: the courage to leave something familiar behind and take a new step. It’s challenging to embark on this journey, but it can pay off—both for you and for the company.

The people who fit this bill can come from all walks of life—from former tax clerks to long-time students to even those with PhDs. What matters most is understanding what drives you and knowing that you’ve got these qualities in spades.

set a course…

When we talk about our trainee program, we’re referring to a period of about six months. That means we have to clearly define what can be achieved during that time (and what can’t). We developed a curriculum that sets the content and the boundaries: our Journey 2 Junior, or J2J for short.

Knowledge has to be built up continuously. Over these six months, we develop skills step by step, chapter by chapter, with each chapter laying the foundation for the next. Essentially, we’ve defined three J2J phases that cover all the technologies, tools, and methods we consider absolute “must-haves”.

Phase 1: Fundamentals
We start by meeting each trainee at their current level and work to bring everyone up to speed. They learn core concepts like object-oriented programming and dive deep into standard Java, databases (and how to access them), testing, and version control with Git, among other things.

Phase 2: Frameworks, Architectures, Interfaces
Once the fundamentals are in place, this chapter usually takes off on its own. Trainees get introduced to key parts of the Spring Framework, start to understand what REST really means, dive deeper into persistence, and explore architectures, design patterns, and more. In the realm of frameworks, those “aha” moments really start to happen—like realizing, “Wow, this automatically handles tasks I used to do by hand, and because I had to do it manually before, I now really understand what’s going on. It’s not just magic!”

Phase 3: Build and Operations
The final phase focuses on topics such as CI/CD, container technologies, cloud deployment, and similar areas. Here, the “aha” moments might come in the form of, “Oh, this is actually possible!” or “Wow, that’s so simple!”

Throughout the journey, the trainees work on a comprehensive real-world project—a continuously evolving application. And they’re never left to fend for themselves. Our skilled trainers are there to guide them, provide constant feedback, answer questions, clarify tasks, review challenges (more on that later), and track each trainee’s individual progress.

It’s about getting people together

We encourage our trainees to engage in lots of discussion—not only to share what they’ve learned but also to connect with others. They do this through “Mini Skill Factories,” which are one-hour presentations on specific technical topics. These sessions are attended by trainees from various disciplines, alumni, and even interested colleagues up to the senior level.
Additionally, several times a year, we hold “Trainee Events.” These bring together the current trainee generation, trainers, and alumni (those who have successfully completed the program). It’s part fun (laser tag, pizza parties) and part networking between current trainees and alumni. On top of that, we promote interaction between trainees and all employees during company events. We’re also thrilled when our trainees attend meetups like Java User Group events to further expand their networks within the local community.

CHALLENGING CHALLENGES

But it’s not just about pizza parties, friendly chats, and networking. Periodically, between two phases, we evaluate each trainee’s progress within the J2J program using various tools—and one of our key tools is the “Challenge.”
At the end of each J2J phase, we set a task with a clear scope that must be solved using at least the technologies, tools, and methods covered in that block. For example, at the end of the first block, the challenge (simplified) requires trainees to implement the behavior of a bank account. Along with an explanatory diagram, we provide a few requirements:

• The customer can deposit money into a bank account (i.e., transfer funds).
• The customer can withdraw money from a bank account.
• The customer can retrieve the current balance.
• The customer can get a list of all transactions on their account.
• The customer can generate account statements that include all transactions between a specified start and end date (inclusive).

From these requirements, the first classes and use cases emerge. To solve the challenge, the trainee must apply what they learned in the first J2J block, such as:

• Object-oriented programming fundamentals
• Standard Java
• Maven
• Data formats
• Git
• Testing with JUnit
• Database access with Java

We intentionally leave out GUI topics here (we don’t see much value in building user interfaces with AWT and Swing these days), along with other topics we classify as “out of scope.”
This challenge is designed to be completed in two person-days by a single trainee. Once the time is up, the trainee’s access to the Git repository is revoked so that there’s no chance of working on it after hours. Then, a trainer conducts a thorough review of the solution. During that review period, the trainee can explore bonus topics. After the review, the trainer and trainee discuss the results to pinpoint any gaps or areas needing improvement—or confirm that everything is on track. In any case, the trainee then moves on to the next chapter, with the opportunity to address any identified issues.

LEssons learned

Over the years, we’ve gathered a lot of experience. Things don’t always go smoothly when you’re building a trainee program like ours, but many aspects have turned out remarkably well.
More than 30 of our employees have gone through the training program in one form or another, and many are still with us today. Our dropout rate has dropped dramatically—in fact, on average, only one trainee fails to complete the program. It’s been so interesting that companies (even competitors!) have reached out asking, “How do you run your trainee program?” With these inquiries piling up, we decided to eventually offer our training program model as a service. We’re excited to see the first case studies come out of it!
On the flip side, things have gone wrong in the past when a trainee relationship ended due to mismatched expectations on both sides, which often made long-term collaboration difficult or even impossible. We’ve learned from these experiences and now emphasize our expectations for trainees as early as possible (ideally during the first meeting, but at the latest just before hiring). We also require prospective trainees to share their expectations of us, or we clearly outline what they can expect from the program.

You keep learning, and in the same way, we continuously expand and improve our trainee program. “Bad” experiences are simply steps on the path to getting better—not setbacks. Inspect and adapt with a human touch.

So, Why Do All This?

Is it just about cheaply producing new developers, or is there more to it? Let me share my personal impressions: over the years, we’ve witnessed some truly remarkable success stories from our trainees—people who were stuck in personal or professional crises, nearly lost to the job market, or who had been stuck in academia for years without really feeling fulfilled. Together, we recognized opportunities, identified potential, and worked through the trainee program. Now, many of these individuals are in lead roles in their projects—roles that once, not even they believed they could fill. You can make a difference and give people a new perspective. Or you can help them achieve their dream of breaking into IT, especially in Java software development. In most cases, this is met with loyalty—a loyalty we return in kind. Besides, it’s also a great way to retain employees in the long run (but that’s a story for another time…).