devopsy.kinsta.cloud

Tag: DevOps Burnout

  • Best of 2022: The Great DevOps Burnout

    Best of 2022: The Great DevOps Burnout

    As we close out 2022, we at devopsy.kinsta.cloud wanted to highlight the most popular articles of the year. Following is the latest in our series of the Best of 2022.

    DevOps needs a mindset shift to save the overworked engineering collective. There’s a considerable discussion right now about the Great Resignation. But if you work in software engineering, you’re probably even more familiar with the Great Burnout.

    Everything in the software development realm has sped up over the last few years. Engineers perform at a rapid-fire pace, with perfect accuracy, all day, every day. The demand for new, updated or better apps never slows down. But your DevOps team can only perform so fast.

    DevOps is Overworked and Burned Out. No, Really.

    A full 83% of software developers feel burnout from their work, while 81% reported an increase in burnout due to the pandemic. The most significant factors contributing to those feelings of burnout include high workload, inefficient processes and poorly-defined project goals and targets.

    Overworking, overloading and burning out developers is a recipe for disaster; that’s resulted in job hopping and low productivity. Organizations need to shift their mindset about how we develop apps and nurture developers to make the future of software development sustainable.

    The Burden of Uneven Engineering Demands on Your Bottom Line

    Software delivery is only as sustainable as the level of workforce happiness. Today, the supply and demand for engineers is entirely lopsided and the chasm between the two continues to widen.

    The highest number of SaaS companies worldwide exist in the United States. The vast majority (73%) of all U.S. businesses are planning to switch to SaaS in the near future; the demand to hire great engineers and find balance will continue to escalate for years.

    Additionally, software developer employment is projected to grow 21% by 2028, faster than the average 5% projected growth rate for all occupations.

    For engineers, this growth is excellent news. But for leadership, the uneven demand for engineers means it’s more important than ever to consider the pain points of your DevOps team and offer solutions to common issues, like overwork.

    Infrastructure Needs to Change to Dampen DevOps Burnout

    Throwing more money and more people at an already overworked engineering culture will not make the SDLC more sustainable nor help you hit business objectives.

    If we take a page out of the “five whys” and dive into the root cause of universal DevOps burnout, there is a common thread in all software engineering approaches. DevOps, Agile, Six Sigma, Lean, Scrum, you name it–these are tried-and-true methodologies that fail if only the symptoms of our infrastructure issues are addressed. We need to reconsider our current tooling choices if we are to appropriately leverage these frameworks for sustainable development.

    Organizations can deflect further engineering burnout and rebound by focusing on saving developers time and reducing toil: The labor engineers devote to repetitive, dull or manual tasks.

    It’s necessary to advance infrastructure with automation and embrace next-gen tools that focus on developer experience to halt further DevOps burnout.

    Let’s Try Something Different: Automate the API

    There needs to be a mindset shift to save DevOps from demise. You can do this by taking a bottom-up approach and introducing more intelligent automation into your software development infrastructure.

    Automation saves developers from mundane or low-value tasks and instead focuses their time and talents on planning, creating and delivering high-quality apps. By improving the quality of DevOps functions, engineers feel more valued and have more pride in their role in the company.

    Automating tasks doesn’t just help the current DevOps team. Embracing automation frees up your existing workforce, requiring lower hiring demand while retaining confidence that their DevOps team is operating at peak efficiency. This approach tackles the root of the problem—too much work, not enough developers—and allows organizations to retain developers long-term by making their work lives more, well, livable!

    Let technology do the mundane, so developers can apply their specialized expertise where it matters. Hire less but do more. Automate workflows so that developers can do their real work: Write code. Sidestep the employment demand issue and protect developers.

    Of course, this approach doesn’t come without drawbacks. Even a near-perfect product can introduce failures if it requires too much customization by highly specialized developers. Then, costs begin to skyrocket because of the manual labor required for API development for customization and database management.

    When done effectively, continuous development is a shining example of improving the infrastructure of DevOps and impacting burnout with automation. Continuous integration and continuous deployment (CI/CD) allow for faster feedback from your customer base, letting you turn around adjustments of features, add or remove things that actually fit and solve problems for your customers faster.

    3 Next-Gen Development Tools to Save Your Team From Continued Toil

    Tackle developer overload by incorporating the next-gen development tools designed to improve the developer experience. Make the workday more manageable, not more complex, with three emerging categories of development tools to fix DevOps burnout.

    1. Automated Code Suggestions
    Context-aware code completion tools suggest code to developers during the coding process. Automated code suggestions save developers precious time (and labor) thanks to fewer keystrokes and are designed to increase the speed of the entire coding process.
    2. Instant API
    With only a few lines of code, instant API connects your data to your app, helping to turn every developer into a backend dev. Whether you need to power a web app or a mobile app, hosting your API and databases in the cloud on one platform allows teams to configure, test and manage APIs without the all-too-familiar manual burden on developers.
    3. Neural Networks
    A branch of machine learning, artificial neural networks are computational models that extract meaning from complex or messy data to detect trends and patterns. Neural networks, while not perfect, can suggest improvements to coders as they write.

    We are doing our engineering workforce a grave disservice by ignoring the Great Burnout and not addressing the shift needed to course-correct DevOps from the ground up. Without the necessary infrastructure automation advancements and adoption of developer-focused tools, teams will continue to battle against velocity demands and churn. It’s time to embrace a new mindset and usher in a new era of DevOps productivity and developer satisfaction.

  • Looking to the Future of Developer Experience

    Looking to the Future of Developer Experience

    Developer experience is where it’s at! Developer experience (DX) means taking a user experience approach to the developer journey. DX (also abbreviated as DevEx) is commonly applied to areas like documentation, sandbox environments, SDK ergonomics and more. By improving a developer’s experience with a tool, software providers can increase stickiness and retain more users.

    Nowadays, having a sleek developer experience is a competitive advantage—especially since developers often have the discretion to purchase new tools. And amid an ongoing skills gap, maintaining quality DX for internal software ecosystems is also important to retaining happy engineers and avoiding burnout. All these factors mean developer experience is becoming a C-suite objective. So, where is DX heading? How will the developer workflow change in the near future?

    I recently met with Ash Arnwine, director of developer relations, Nylas, to ponder what’s on the near horizon regarding developer experience. According to Arnwine, DX is still a very new concept. Yet, it has become an integral aspect of positioning modern software, especially for public-facing SaaS, and will undoubtedly drive purchasing decisions in the year ahead. Below, we’ll share some predictions of how DX will evolve within four general categories: onboarding, building, deploying, and maintaining.

    State of Developer Experience

    First off, what is the state of developer experience within the tech world at large? Well, Arnwine is quick to note that the concept is still relatively nascent. “Developer experience was something that we didn’t talk about that long ago.” Yet, the idea is growing in mindshare as developers exercise greater control over the software life cycle.

    In fact, the 2022 StackOverflow survey found that 66% of professional developers have at least some influence over their organization’s purchases of new technologies, up from 56% in 2020. Furthermore, the way developers learn is changing. The new generation of programmers is primarily self-taught, relying on coding bootcamps or other online resources. An impressive 70% of developers learned how to code from online resources.

    What we end up with, said Arnwine, is a growing developer population with a much wider range of skills than in the past. And since no one is there to hand-hold them, the technology itself must be usable and intuitive—the onus is on the software provider to craft frictionless self-service workflows. And with developers’ growing influence in purchasing, DX becomes a competitive advantage and an executive talking point, said Arnwine.

    Onboarding

    Developer experience is a broad topic, but it’s most often associated with the time it takes to get started with a tool. This is often referred to as ‘Time to First Hello World.’ But although it’s an important step, the metric might doesn’t always carry much significance. Time to value, on the other hand, said Arnwine, takes this a step further and is a better gauge of success.

    For example, onboarding to a web API would likely involve the signup process, creating an account, getting API keys and perusing the documentation—all before a first call is sent. According to Arnwine, there are techniques to apply at this stage to help developers move faster throughout the onboarding process to reach value sooner.

    Here are some ways in which developer onboarding is becoming more streamlined:

    • Automatically generating keys upon signup.
    • Providing a terminal within the developer dashboard to test sample code.
    • Handing developers the code they need to be customized to their specific stack.
    • Using specifications as a single source of truth for documentation.

    Building

    What can SaaS companies do to help improve DX while building? Well, one way is to enable auto-complete within IDEs. When developers onboard with a new tool, they are often handed an SDK and reference documentation. But, it doesn’t add value to send programmers back and forth between a browser to look up method names. Instead, Arnwine believes developer tools should be “baked into the IDE in a way a modern developer would expect.”

    One example of auto-complete on steroids is Fig, a next-gen command line that supports auto-complete for over 500+ popular CLI tools. Taking this a step further is GitHub Copilot, an AI assistant that can take natural language prompts and generate pretty complex code suggestions. The industry appears to be heading toward more AI-fueled low-code software development—a trend that could significantly improve a developer’s experience during the construction process.

    However, one potential downside of increased software development automation is ensuring the AI suggests correct code snippets. Thus, Arnwine said he anticipated possible troubleshooting and debugging problems. Furthermore, SaaS providers will have to vet systems that generate glue code to ensure it’s accurate and up-to-date with the latest versions. His advice to SaaS providers is to meet developers where they are, but do their best to maintain a quality experience that they can control.

    Deploying

    For a long period of software development history, IT administrators were the only ones able to deploy software. The old-school method required getting a hosting provider, installing Ubuntu and plenty of other legwork. Nowadays, however, software deployment has become far more drag-and-drop. DevOps has become more democratized in recent years, and we will likely see greater usability emerge in the years ahead.

    One way to increase developer experience for deployments is through more custom automated routines via GitHub Actions or similar event-based systems. And plug-and-play pre-built actions could reduce the barrier to using such systems. Such connectivity is necessary to enable a docs-as-code approach, said Arnwine.

    Maintaining

    Another area that could use a serious developer experience upgrade is dependency management. Software dependencies go through a life cycle. They are versioned, updated, retired and sometimes replaced outright. As such, keeping track of an evolving surface area of third-party dependencies can be a headache. To make matters worse, software supply chain threats have complicated the integrity of many open source dependencies consumed by most applications.

    Although it’s imperative for organizations to maintain parity with dependencies, a single person is rarely tasked with continuously checking dependencies and monitoring for security threats. Therefore, more automation for dependency management and security monitoring is necessary. For example, Arnwine uses Snyk, which sends a weekly report on the state of his dependencies.

    Final Thoughts

    Assuming you have the killer functionality to back it up, an investment into developer experience can help a developer tool stick out in a crowded marketplace. But of course, improving the DX means many different things depending on your context. It could be a subtle user interface tweak, adding relevant code samples or making your documentation more intuitive.

    On the other hand, a negative developer experience can turn away potential users and cause frustration throughout the application support life cycle. This can instill a poor reputation among programmers.

    To review, in the near future, we’ll likely witness the developer experience evolve in the following areas:

    • Enhanced methods that streamline the signup process.
    • Auto-complete and AI-driven code suggestions that understand a developer’s stack and meet them where they work.
    • More intuitive, automated deployment models.
    • Increased automation around the maintenance of dependencies.

    While developer experience is a growing concern, it shouldn’t be the only measurement of a SaaS — the ongoing value it brings developer consumers and end users is just as (if not more) important to consider.

  • How to Prevent Turnover in DevOps Teams

    How to Prevent Turnover in DevOps Teams

    Turnover is all too common in software engineering. The Bureau of Labor Statistics 2021 report found that the average software engineer turnover is 57.3%. It’s a programmer’s market, and these sought-after folks might jump ship for a higher salary, better work-life balance, different team dynamic or perhaps even for a company with a better ESG footprint. Yet, constant changeups in a development team can stifle progress when there’s pressure to meet new digital demands and rapidly deliver new features.

    IT skills shortages can impede innovation across the board. But turnover can be especially problematic in the field of DevOps, as the practice relies on collaboration between teams and a shared sense of operational standards. Here, a gap in shared knowledge can impair ongoing platform maintenance.

    I recently met with Nathan Sutter, global VP of engineering at CoderPad, to examine the core reasons behind engineering turnover and look at specific ways to prevent it in DevOps teams. In a nutshell, he advocated for reducing context switching, giving both engineering and product teams a seat at the table and not underestimating your teammates’ flexibility.

    Reduce Context Switching

    Engineers like having ownership and pride around what they’re creating—take that away, and it can lead to burnout and even an exit from the company. The more you context switch, describes Sutter, the less you focus on building a core project and the less attached you feel to the code or architecture you’re creating. “Engineers like to build cool stuff, ship it, and use it,” he said.

    Context switching may occur for a couple of reasons. First, it may just result from poor planning, in which case engineering time is wasted. Secondly, context switching might arise due to legitimate emergencies, such as incident response or necessary bug fixes. Furthermore, enterprises traditionally ship operational concerns to a production team, thus increasing the number of applications a developer oversees and decreasing their role in ongoing maintenance.

    Instead, Sutter is a proponent of allowing developers to own everything about an application end-to-end. Essentially, the DevOps or infrastructure team builds the scaffolding and the application teams own the rest, such as writing Terraform configurations, Docker containerization, monitoring and alerts, and on-call assistance. In other words, you operate what you build and own the component throughout its entire lifecycle. This practice has already been embraced by full-cycle developers at Netflix.

    Specifically, in DevOps, the on-call cycles can be challenging when you have so many things to own. “When you have 25 apps to look after, something is always going off,” said Sutter. “This is an “exhausting, thankless and horrific way to work.” This imbalance can affect the work-life balance and decrease your time to focus on upgrading core infrastructure.

    Don’t Separate Engineering and Product Teams

    Another setback that might manifest itself in turnover has to do with inefficiencies caused by siloed teams. For example, suppose a product team spends months outlining a complex software design in a black box. In that case, they will most likely encounter many issues once the schematics are finally sent to engineering teams. Without collaboration between the two groups earlier on, organizations can increase time-to-market for new features and encounter frustration between teams.

    Instead, Sutter believes product and engineering teams should counterbalance each other and collaborate more in the product design phase. Whereas product teams can “skate where the puck is going” and identify trends in the market, engineering teams figure out how to technically implement these designs and build a sequence of work that’s scalable for the long-term. Of course, the other side rings true, too—engineers can overplay their hand and plan minute details too far into the future, described Sutter. This underpins a need for ongoing collaboration where both sides have a voice at the table.

    Don’t Underestimate Flexibility

    Even though software engineers like to have a sense of ownership, we shouldn’t discourage flexibility—people easily become bored working on the same thing for years and years. There’s also the fallacy of sunk cost to keep in mind, which states that we tend to value things more because we’ve put more time and effort into them. Thus, providing flexibility to pivot when it makes sense can increase overall satisfaction and output.

    Accordingly, flexible management is also crucial to embrace pivots when they are necessary. For example, if a project is well underway but an engineer identifies a new solution that is more elegant, team leads should be open to recognizing and acting on changes. But to realize this sort of relationship, trust and openness must be bidirectional, said Sutter. If engineers can’t express their ideas or are afraid to tell their boss they’re wrong, these important conversations can’t happen.

    A flexible structure is also necessary to attract talent that prefers more modern work-life balance. As big tech companies with multimillion-dollar commercial leases now want workers to return to physical offices, small-to-medium companies now have an unprecedented upper hand to attract and retain talent if they embrace flexible remote-hybrid working options, added Sutter.

    What Matters Most?

    The majority of developers working on open source projects are open to changing jobs in 2022, according to the EDB Open Source Talent Survey. Job satisfaction is challenging to wrap your head around, and each engineer may be motivated by various reasons.

    But having assembled and led many software engineering teams over the years, Sutter recognized an interesting change in the attitudes of what matters most to software engineers in their day-to-day job. Pre-COVID, software engineers were definitely interested in higher compensation, he said. After that, it was building something they’re proud of, team camaraderie, the worth of a brand name and a positive work-life balance. Post-COVID, compensation and other benefits are still just as valid. Yet, hybrid flexibility is often table-stakes—some are even willing to take a pay cut to obtain these benefits. This underscores the high importance of flexibility in managing modern software engineering teams.

    Executives and engineering leads have their work cut out for them when it comes to obtaining and retaining top talent. Yet interestingly, many roadblocks are not so much technical problems but people and organizational problems. As we’ve covered, reducing context-switching and placing more ownership on singular products could increase satisfaction. One of the tenets of DevOps is also de-siloing teams to increase collaboration. Reducing toil could also go a long way toward increasing satisfaction. Whatever your chosen strategy, it’s always good to “display openness and understanding to hear people when they’re not happy,” said Sutter.