Navigating the Complexities of DevOps as a Single Parent

Navigating the Complexities of DevOps as a Single Parent

Balancing career growth and family life in the ever-evolving tech landscape.

I started my career in IT Support—a role that was straightforward and predictable. Over time, I transitioned into DevOps, a field that, while exciting and innovative, often feels overwhelmingly complex. Recently, while working on personal projects like Linkarooie (an open-source version of Linkfree/BioDrop that I created after it was sunsetted), and Echosight, a social media analytics platform, I’ve grappled with self-doubt, questioning whether I’m truly cut out for this line of work. Tasks that are supposed to be “easy” sometimes feel insurmountable, especially when dealing with legacy applications in my professional environment, Dockerising, and deploying on platforms like AWS.

The Challenge of Dockerising Linkarooie

One particular challenge I faced was Dockerising Linkarooie, which I built as an open-source alternative to Linkfree/BioDrop. After Linkfree was sunsetted, I couldn’t find a replacement that fit my needs, so I decided to create my own solution from scratch. Dockerising the project and setting up CI/CD pipelines was anything but smooth. I found myself entangled in the intricacies of:

  • Version Managers: Navigating different Ruby versions using tools like RVM or rbenv.
  • Gemfiles and Bundler: Managing dependencies and understanding how Gemfiles and Bundler work together.
  • DigitalOcean and Docker: Hosting Linkarooie on DigitalOcean, managing Docker containers, and configuring the necessary infrastructure.

The leap from getting the app running locally to deploying it in a production environment was monumental. Each environment had its own set of dependencies and configurations, making the task feel like piecing together a puzzle without a reference picture. This wasn’t just a technical challenge but also a strategic one, as I wanted the project to be scalable and maintainable for anyone who might want to use or contribute to it.

Breaking Down Overwhelming Tasks

Before having the entire system working end-to-end, I didn’t fully grasp which components were necessary or how they fit together. It was only after numerous trials and errors that I could break down the project into manageable parts. It was similar to juggling parenthood and work: at first, everything feels overwhelming, but by breaking tasks down into phases, the complexity becomes more manageable. This realisation came only after wrestling with the entire system—a process that was both time-consuming and mentally exhausting.

I realised that each phase of the project needed to be broken down repeatedly before it reached a point where I could cope:

  1. Phase 1: Local Environment Setup

    • Setting up Ruby environments using RVM/rbenv.
    • Understanding the nuances of Gemfiles, Bundler, and version management.

  2. Phase 2: Bridging Dev and Production Environments

    • Transitioning from a local dev setup to a production environment hosted on DigitalOcean.
    • Managing different configurations, Docker containers, and handling deployment challenges.

  3. Phase 3: Working with AWS and ECS (Professional Work)
    In my professional DevOps work, I faced different challenges working with AWS and ECS. Unfamiliarity with services like ECS, combined with the complexity of managing Docker in AWS environments, added an extra layer of difficulty. Working within legacy CI/CD pipelines through third-party service providers meant constantly troubleshooting issues related to deployment failures and configuration mismatches. This experience pushed me to improve my understanding of large-scale, cloud-based environments and develop strategies for managing the vast differences between development and production environments.

  4. Phase 4: Managing Manual Systems (Linkarooie and DigitalOcean)
    For Linkarooie, I worked with DigitalOcean. While simpler than AWS/ECS, there were still major challenges involved in manually managing Docker containers, scaling the system, and ensuring the reliability of services like Redis and Sidekiq. The need to manage everything myself taught me the importance of staying on top of every component and ensuring smooth operation without the large-scale automation tools available in corporate environments.

Each of these phases presented its own set of challenges, and breaking them down further was necessary for me to progress.

Balancing Career and Parenthood

Balancing this demanding career with my responsibilities as a full-time single parent adds another layer of complexity. Remote work isn’t just a perk for me; it’s a necessity. I need the flexibility to take my daughter, Kaylee, to school in the mornings and be present for her after school. Beyond that, she’s a huge part of why I push through these technical challenges. Every time I hit a roadblock—whether in Dockerising Linkarooie on DigitalOcean or dealing with more complex AWS environments at work—I think about how my persistence serves not just me, but her future. My journey in DevOps is as much about providing for her as it is about advancing my career.

The Vulnerability of Stability

I often worry about my job security. In the tech industry, where advancements happen at breakneck speed, there’s always someone more skilled or knowledgeable. I sometimes feel like I’m just keeping my head above water, especially when I compare myself to peers who seem to navigate these challenges with ease. However, I remind myself of past experiences where I faced similar uncertainties—like when I first transitioned into DevOps or when I wasn’t as familiar with Docker and AWS. Each of those moments pushed me to learn, adapt, and come out stronger.

Embracing Continuous Learning

Despite these feelings, I recognise the progress I’ve made. Working on personal projects like Linkarooie (hosted on DigitalOcean) and Echosight has forced me to learn new tools and technologies. In particular, Linkarooie gave me the opportunity to work with DigitalOcean, Docker, and Redis—tools that I wasn’t as familiar with in my professional environment. On the other hand, my work with AWS and ECS in a professional capacity taught me the intricacies of scaling, managing multiple environments, and handling complex CI/CD pipelines. These experiences have allowed me to:

  • Enhance my skill set with modern tools and technologies like Docker, AWS ECS, and CI/CD pipelines.
  • Adapt to complex systems, learning to manage projects end-to-end, whether they are legacy applications in the workplace or open-source projects like Linkarooie.
  • Balance professional growth with personal responsibilities, applying what I’ve learnt to both my day job and personal projects.

While I may sometimes only know what needs to be done rather than how to do it in detail, I’ve come to realise that this strategic understanding is valuable in its own right.

I still grapple with vulnerability and self-doubt, but I’m learning to focus on the strengths I bring to my role. Being a single parent has taught me how to handle stress, adapt to unpredictable circumstances, and keep pushing forward—even when things don’t go as planned. This mindset has been invaluable in DevOps, where the ability to troubleshoot and persevere through challenges is just as important as technical knowledge.

Conclusion: Finding Balance in Complexity

In sharing this, I hope others in similar situations realise they’re not alone. The tech industry can be demanding, but it’s also filled with opportunities for those willing to navigate its complexities—especially when you’re doing it not just for yourself, but for the people who depend on you. Whether it’s through contributing to open-source projects like Linkarooie (which you can find on GitHub), or simply sharing experiences, we can all grow and support each other on this journey.