How the Ignite Program Helped Us Become New Relic Software Engineers

Earlier this year, New Relic kicked off the Ignite program—our incubator for early career engineers. New Relic designed the Ignite program to increase opportunities for early career engineers by giving them extra support, mentoring, and coaching, as well as exposure to a broad technical overview of the company’s systems. The goal was to reduce the costs and risks in hiring early career engineers, and to deliver high-performing engineers from day one.

Three of us—Joshua Jones, Eileen Szeto, and Xi Xia—made up the initial Ignite cohort. We have now completed the program and have moved up from being Associate Software Engineers (ASEs) to taking positions as Software Engineer 1 on various teams within New Relic. This post is our story.

Don’t miss: Introducing New Relic’s Ignite Program for Early Career Engineers

Each of us started the Ignite program with different areas of domain knowledge. After an incredible first leg of our journey, we’ve worked together to assemble an overview of the skills we have either learned or have started learning. To be clear, we’re not in a position to give anyone an exact set of steps to become a New Relic engineer, but we can identify skills we are grateful to have gained in the past months—and can offer some actionable steps we might take if we were to start from the beginning again.

Some skills we learned in Ignite

At one point or another during the Ignite program, we all shared the feeling of, “Oh, I see... I just have to know everything.” One of the many benefits of the Ignite program was that our manager, John Hyland, was always available to help clarify the expectations for what we would need to know by the conclusion of the program. As we rotated onto different teams each week— working with engineers at various points in their careers—we were able to see how these skills were applied in an engineer’s workflow.

We’ve split those skills into four tiers:

1. Basics: Read a guide or two and understand the high-level overview and key concepts of a tool or skill.
2. Dangerous: Practice the Basics with tutorials or on a project.
3. Applied: Start to gain real familiarity with a tool or skill.
4. Subject Matter Expert (SME): Gain enough comfort that you're able to teach a tool or skill at a professional level.

On the Basics skills level, we were expected to know:

• The DevOps cycle of software development
• The ways successful teams build and maintain services in distributed systems
• Testing strategies like TDD (Test Driven Development) and Integration Testing
• How to use Grand Central (a New Relic build-pipeline tool)
• How to use NOS (a New Relic tool) to create a new project
• Apache Kafka

We were expected to be Dangerous with:

• Command-line networking
• Command-line Bash
• Version control using git
• Docker
• Databases like MySQL or Postgres
• Coding tools such as IntelliJ, Visual Studio Code, and VIM.
• Tracing a series of method calls through someone else’s codebase that enables a certain functionality to exist.

At the Applied tier, we needed to know:

• How to build a full-stack application using a web framework such as Rails
• How to build the app with TDD and unit tests
• Some language basics, starting with the languages we use at New Relic (Java, Kotlin, Ruby, Elixir, and JavaScript).

At no point, were we expected to become SMEs in any given area, and this was a big take away—we didn’t have to know everything after all! It turns out that being a software engineer is all about asking questions, learning efficiently, troubleshooting issues you’ve never seen before, and remaining curious.

But how can I learn {X}?

The Ignite program provided invaluable runway that helped us pick up many of these skills quickly, but we also learned a great deal through various forms of self-directed study. Here are some of the learning paths that proved most valuable to us:

Read the documentation. No matter how many times someone says to read the instructions, it seems to be standard human behavior to skip straight to the “doing,” referencing the instructions only when an issue arises. We did not always follow this advice, but when we did read the documentation, it usually helped us avoid some low-hanging obstacles and progress more quickly to the good stuff.

Use books and tutorials. We each have our own learning styles, but we all found value in working through guided exercises and examples when getting up to speed on a new skill. Tutorials and books helped us understand how to solve issues idiomatically within a domain while providing early hands-on experience with important tools. If one style of writing or video content does not fit one’s needs, we would encourage learners to continue to try and branch out.  There are so many learning resources available in 2019, there is sure to be something for everyone.

Build your own projects. While books and tutorials are useful, it can be tempting to remain in a safe learning environment, working only on projects designed by someone else. When we took a chance and started building our own projects, we found that we were able to progress even faster and in different ways. Applying skills learned from tutorials and books to problems we saw our colleagues struggling with provided a unique opportunity to troubleshoot in real-world scenarios. Sometimes, we even got to work with real user feedback on our ideas.

We found this experience particularly useful when learning new technology stacks and frameworks during the Ignite program. Even picking up a rough idea of the types of design challenges a larger project might face or the cost of maintaining a service long term provides a great starting point to add new skills quickly.

Pairing with others. One of our favorite parts of the Ignite program was the opportunity to work with other engineers on coding projects, whether we were pairing with senior engineers or just us three associate software engineers. Working together provided exposure to other points of view and helped expand our problem-solving toolsets. Working with senior engineers showed us time-honed processes for efficiently moving around a code base, constructing new functionality, and refactoring existing functionality. Pairing with the other ASE’s let us combine each of our past experiences into a larger knowledge pool and go farther on our own than we would have ever expected!

Looking back

All three of us enjoyed participating in the first Ignite cohort. We had the opportunity to meet so many knowledgeable engineers, managers, product managers, and more, and we learned from several different teams along the way. Seeing how processes vary from one team and domain to another gave us good ideas for tools we might apply on our future teams, and helped us get a bigger overall picture of New Relic's services.

We hope to encourage anyone interested in participating in the Ignite program to try some of the learning steps above. Don’t be afraid to apply—Ignite is continuing to grow and evolve, and we have high hopes for its ability to help other early career engineers.

Happy coding!

(If you’re interested New Relic’s Ignite program, please keep an eye on our careers page. We expect that openings for next year's Ignite cohort will go live sometime in the next few months!)