Tag: collaboration

SRE vs. DevOps is a False Choice: Here’s the Unified Model That Works

The current agile environment puts pressure on teams to go fast and remain reliable. It is a common practice to portray DevOps and site reliability engineering (SRE) as competing strategies for going fast versus remaining reliable. The truth is that DevOps and SRE are two sides of the same coin, and the best experts argue that they are complementary to each other.

Google’s SRE team stresses: The closeness between DevOps and SRE is much more similar than most people assume. One thing is clear: Organizations do not have to choose between DevOps and SRE, they can combine both techniques. More often than not, high-performing teams combine DevOps culture with SRE.

DevOps: Culture and Collaboration

DevOps arose around 2009 as a cultural movement to break down silos between developers and operations. Its core idea is shared ownership of the software life cycle: ‘Development and operations’ work as one team rather than hand-offs. In the words of the DevOps Institute, DevOps is “a collaborative approach to the tasks performed by an organization’s application development and IT operations teams”.

The focus is on automation and continuous feedback. Practices such as CI/CD pipelines, infrastructure as code and frequent small releases are central. DevOps pioneers distilled this philosophy into the culture, automation, lean, measurement, and sharing (CALMS) framework, highlighting that a supportive culture underlies any tooling push. In short, DevOps seeks to accelerate delivery by empowering developers while breaking down blame and bottlenecks.

SRE: Engineering for Reliability

SRE started at Google as a way to apply software engineering to operations. SRE’s basic tenet is that ‘doing operations well is a software problem’. In practice, this means building code and automation (rather than manual toil) to manage infrastructure. Google formally defines its SRE practice as “an approach to operations that prioritizes user-centric measurement, shared accountability and collaborative, blameless learning.”

This translates into concrete practices: Every service has service level indicators (SLIs) and agreed service level objectives (SLOs) for uptime, latency, error rate, etc. The SRE team and product team jointly decide on an error budget, a tolerated amount of failure, so that developers can continue innovating without compromising reliability. SREs then build monitoring, alerting, on-call rotations and automated runbooks to ensure those SLOs are met. In short, SRE codifies reliability targets and treats system stability as an engineering challenge.

Shared Principles and Common Goals

At their core, DevOps and SRE share a common mission. Both aim to eliminate silos and improve systems through automation and measurement. Both practices encourage collaboration, cross-functional teams and a blameless culture of learning.

In fact, both SRE and DevOps engineers perform similar tasks: “Monitoring, optimizing system performance and troubleshooting issues,” according to Splunk. The tooling largely overlaps, too. For instance, teams on both sides use similar observability stacks, such as Grafana, Prometheus, Splunk or ELK for logs, tracing and metrics, to detect anomalies and debug incidents.

This synergy extends to philosophy. Google’s SRE authors note that if DevOps is the philosophy, then “class SRE implements interface.” In other words, SRE brings DevOps ideas into code and concrete practice. Adopting the SRE model actually embraces and accepts the differences between operations and development while encouraging teams to work toward a common goal.

In practice, they discovered that using SLOs and error budgets put devs and ops on the same page. The error budget approach caused both teams (dev and ops) to make similar decisions when faced with reliability versus feature trade-offs. In effect, DevOps and SRE both value automation, shared responsibility and continuous improvement; they just use different levers (culture versus software) to get there.

A Unified DevOps + SRE Model

Given these overlaps, the unified model is simply DevOps and SRE working together in perfect harmony. It looks like a culture where everyone owns a piece of the process, plus some clear rules to keep things on track. In practice, a developer might be in charge of a service from start to finish (that’s DevOps), but they’ll work hand in hand with an SRE to figure out what ‘good’ looks like for that service (which is the SRE part). The SRE will help set up those CI/CD pipelines and monitoring tools that keep the service’s performance in line.

For example, a team might automate their code deployments with a pipeline that includes built-in tests and get a dashboard showing uptime and error rates — all courtesy of the SRE. If things start going wrong and they’re running low on their ‘error budget’, the team will take things easy on new releases and fix the infrastructure before things get worse.

Platform teams and internal developer platforms (IDPs) often make this model a standard part of how they work. A modern platform team will create what they call ‘golden paths’, pre-made workflows and templates that include all the best bits of both DevOps and SRE. For instance, let any engineer spin up a Kubernetes service with just a few clicks on a special catalog, and the IDP will sort out the rest.

Under the hood, what’s happening is the platform is automatically setting up the underlying infrastructure (using Terraform scripts), so all the logging, monitoring, alerting and SLOs get included. The engineer doesn’t have to get tangled up in all that low-level stuff; they just follow the golden path — it’s how you get reliability checks in place without slowing down the developers.

Tools and Practices

Teams using this unified model have a common set of tools to work with. They’re able to scale and keep their deployments healthy — thanks to container orchestration tech such as Kubernetes or ECS. With tools such as Terraform and CloudFormation, they can make sure their different environments are all reproducible and well-documented. Moreover, they get the automated build/test/deploy process going with CI/CD systems such as Jenkins, GitLab CI, GitHub Actions, Spinnaker or Argo CD — all of which give the developers instant feedback as they work.

But what really matters here is that they have observability and monitoring tools such as Prometheus/Grafana, Datadog, Splunk, New Relic or Elastic, all fully embedded into the process. These tools are picking up all the SLIs that drive their SLOs and incident response — it’s all about having those numbers. On top of that, they’ve got ChatOps and automated incident responders such as PagerDuty and OpsGenie, bringing alerts right into the team’s workflow. All this tech is actually supporting super-fast deployment and ironclad operations, which shows that the tech choices we make in DevOps/SRE land must be able to keep up for both.

Metrics and Measurement

One of the major benefits of the unified approach is that the decisions made are data-driven. For the DevOps community, the DORA metrics (deployment rate, lead time for changes, MTTR and change failure rate) are used to measure the rate of delivery. Meanwhile, for the SRE community, the SLIs/SLOs for availability, latency and errors are used to measure reliability. The important point is that these metrics meet at the middle ground. Google’s Accelerate (DORA) research group took this a step further and identified the fifth key metric: Reliability. This takes into consideration the availability and error rate.

This reinforces that stability is a performance criterion as surely as speed. Well-performing squads are tracking dashboards that show, for instance, ‘98.9% successful deployments’ and ‘99.5% uptime’ at the same time. As soon as deployments are about to breach the error budget, pipelines can be throttled and self-rolled back based on SRE policies to take automated actions. In other words, DevOps metrics and SRE metrics feed each other to form different types of feedback loops that keep development fast and secure.

Conclusion

DevOps and SRE are not a zero-sum game. Rather, they form a virtuous circle, in which cultural change, made possible by DevOps, gives everyone the ability to deliver software at high velocity, and the discipline of SRE makes sure that this software works, resulting in high-quality software being delivered faster.

From a practical standpoint, this helps developers own the services in production, ensure agreed-upon levels of reliability are met, have testing and rollback enforced by the pipelines and deal with incidents clearly and learn from them. By integrating the principles of DevOps and SRE, via platform engineering or the use of IDPs, innovation velocity and stability are achieved. Ultimately, the future lies in DevOps with SRE, and its success has already been proven in multiple countries worldwide.

February 13, 2026
Former GitHub CEO Bets $60M That Developer Tools Need a Factory Reset for the AI Age

Thomas Dohmke spent nearly four years running GitHub and helped turn Copilot into the most widely used AI coding tool globally. Now he’s starting over—with a very different thesis about where software development is headed.

His new company, Entire, emerged from stealth today with a $60 million seed round. Silicon Valley firm Felicis led the deal and called it the largest seed investment ever for a developer tools startup. The list of backers reads like a who’s who of tech: Madrona, Microsoft’s M12 venture arm, Basis Set Ventures, Yahoo co-founder Jerry Yang, Y Combinator CEO Garry Tan, and Datadog CEO Olivier Pomel. Developer community figures Gergely Orosz and Theo Browne also participated. The round values Entire at $300 million.

The Core Idea

Dohmke’s argument is straightforward: the tools developers use today were designed for humans writing code. But that’s not how software gets built anymore. Teams are increasingly managing fleets of AI coding agents that generate large volumes of code. The existing toolchain—version control, code review, and CI/CD—wasn’t built for that workflow.

Entire wants to rethink the software development lifecycle for a world where AI agents are the primary code producers, not humans.

“Just like when automotive companies replaced the traditional, craft-based production system with the moving assembly line, we must now reimagine the software development lifecycle for a world where machines are the primary producers of code,” Dohmke said. “This is the purpose of Entire: to build the world’s next developer platform, where agents and humans collaborate, learn, and ship together.”

First Product: Checkpoints

Entire’s first open-source release is a command-line tool called Checkpoints. It addresses a real problem: when an AI agent writes code, the reasoning behind the changes is often lost. Checkpoints records the instructions and reasoning behind AI-generated code and stores that context alongside the code itself. This gives teams visibility into how and why changes were made—something that matters a lot when you need to review, debug, or audit AI-written software.

Checkpoints launches with support for Anthropic’s Claude Code and Google’s Gemini CLI. Support for other popular agents is planned.

This is a practical starting point. Anyone who has tried to review AI-generated pull requests knows the pain of staring at code with no clear explanation of the intent behind it. Checkpoints address that gap directly.

Why This Matters for DevOps Teams

The shift Dohmke is describing has real implications for how DevOps teams operate. When AI agents write most of the code, the review and governance layer becomes critical. You need to know what prompted a change, what the agent’s reasoning was, and whether the output meets your standards.

Current DevOps pipelines assume a human wrote the code and understands the context. That assumption breaks down fast when you have multiple agents generating code across a codebase.

“We are approaching a tipping point where the code-centric IDE paradigm stops scaling. As AI agents become the primary producers of code, developer experience shifts from editing files to directing, supervising, and validating automated work. Thomas Dohmke is right to call for a factory reset because the existing toolchain was designed around human authorship, not machine-scale generation,” according to Mitch Ashley, VP and Practice Lead, Software Lifecycle Engineering, The Futurum Group.

“What Entire is signaling is a move toward an agent-optimized development experience where intent, reasoning, and governance travel with the code. That reframes DevOps from managing commits to managing agent behavior, accountability, and evidence. Tools like Checkpoints point to where value concentrates next: making agent-driven development observable, reviewable, and governable at scale.”

A Crowded Market

Entire enters a competitive space. Google, OpenAI, Anthropic, Microsoft, Cursor, and others all offer AI coding tools and platforms. However, most of those focus on the code-generation side. Entire is betting that the bigger opportunity is in what happens after the code gets written—the review, governance, and collaboration layer.

That’s a different bet, and it makes sense given Dohmke’s experience at GitHub. He knows the developer workflow better than most, and he understands that tools succeed when they fit naturally into how teams already work.

The Team

Dohmke moved to the U.S. after selling his startup HockeyApp to Microsoft in 2015. He became GitHub CEO in 2021 and led the company for nearly four years before leaving last August to build Entire.

The company has 15 employees, all remote, with team members who previously built developer tools at GitHub and Atlassian. They plan to expand as they work toward a broader platform launch later this year.

Entire is based in Bellevue, Washington, which puts it squarely in the middle of the Pacific Northwest’s developer tools ecosystem.

What to Watch

The real test for Entire will be whether they can build a platform that teams actually adopt. Open-sourcing Checkpoints is a smart first move—it gets the product into developers’ hands without a sales cycle. But the long-term play is clearly a broader platform, and that’s where the $60 million comes in.

If Dohmke is right that the software development lifecycle needs to be rebuilt for AI agents, Entire has the funding, team, and credibility to make a serious run at it. If he’s wrong, $300 million is a lot of valuation for a command-line tool.

Either way, this is a company worth watching.

February 11, 2026
Gain Control of Your Innovation With Low Code Technologies

As an entrepreneur and CEO of a large global company, I once believed that building an exceptional business technology infrastructure meant creating it entirely from scratch. To me, software coding and development were processes that demanded immense specialized skill, consumed significant time and incurred substantial costs — precise, yet never agile.

That’s why I was so impressed to discover low-code technology — a sophisticated approach to software development for applications and systems, which delivers remarkable speed and flexibility. It can be implemented with minimal hand-coding, leveraging visual interfaces and drag-and-drop functionality, enabling professionals with limited technical expertise to build applications more efficiently.

Thanks to low-code technology, you can assemble unique systems using high-quality, pre-engineered components, much like advanced Lego bricks. Instead of working from scratch, you simply snap together ready-made components to define workflows and connect various elements of a system, even adding custom code when needed to adapt to your business needs.

Studies suggest that low-code technology can help achieve up to a 90% reduction in development time compared to traditional coding methods. Again, you don’t need to know how to make the Legos — just how to put them together.

Our global team at RunMyProcess, a cloud-based platform for low-code application development, builds robust business tools — customer portals, internal dashboards and tailored workflows — in days or weeks, not months. Our experts quickly bring solutions to life, freeing clients’ teams from complex challenges.

This approach also allows for broader participation, enabling more team members to contribute to progress through technology, driving innovation and fostering deeper collaboration. More importantly, low-code technology empowers businesses to turn ideas into functional applications, bringing products and services to market faster. You no longer have to risk your IP while navigating a complex, time-consuming process to reach the market. With low-code technology, you can transform an idea into a reality faster than ever before.

Today, having a collection of brilliantly built elements is one thing, but making them work together seamlessly is another. That’s where orchestration transforms operations. Envision your entire business as a grand orchestra, with distinct sections such as sales, finance and operations, each playing its part in sync.

Without a conductor, each section might play its part independently, which means not performing as efficiently or productively as possible. A customer order comes in, the sales section acts and then someone manually cues finance, followed by operations. This chain of manual handoffs often results in delays and errors.

In real terms, effective orchestration relies on software platforms like RunMyProcess to automate and coordinate complex tasks across systems and departments. Our platform seamlessly merges human and AI data into a torrent of information. It eliminates wasted time and reduces errors that arise from manual coordination, making operations faster and more accurate.

Forget the intimidating jargon surrounding orchestration’s elaborate architectural patterns and other intricacies. At its core, the technology automatically ensures that every instrument, department and software system plays its part perfectly and in sequence.

Our high-performance cloud platform has helped major retailers, manufacturers, insurance companies, agribusinesses and service providers streamline their processes, improving both speed and efficiency.

For example, a publisher burdened by manual edits, lost files and endless emails used the RunMyProcess DigitalSuite to automate workflows. This eliminated 200 hours of weekly busywork, cut article turnaround time in half and gave editors more time to focus on content quality.

Similarly, a global farm machinery manufacturer overcame slow, error-prone paper inspections by using RunMyProcess’ platform to create a custom digital check sheet. Within weeks, it accelerated quality control by 30%, improved inspection accuracy and gained real-time access to production data — enabling faster fixes and more consistent quality.

Bringing together the two tools creates a powerful synergy: Low-code accelerates application creation, and orchestration ensures those applications integrate smoothly across the entire organization. Ultimately, that combination helps companies control costs and manage complexity. While I’ve seen firsthand how these changes make a real difference, as with any construction project, thoughtful planning and skilled integration are essential to ensure everything fits and functions. Lego bricks and orchestra conducting work well as simplified images, but real-world integration is often more complex.

Still, what truly stands out is how collaboration improves. It’s not just the tech folks at the forefront — people across the business can contribute. Processes become clearer, and it’s easier for everyone to get involved.

In the end, fusing low-code and orchestration is more than a technical upgrade. I see it as a business imperative and an empowering shift that is reshaping how leading companies get work done, and who takes the lead. It creates a foundation for resilience, agility and profitability — turning today’s innovations into tomorrow’s advantages.

November 5, 2025

Bridging the Gap: How DevOps Fosters Collaboration and Rapid Delivery

The modern software development landscape depends heavily on DevOps, which extends beyond basic tools or automation scripts. The fundamental essence of DevOps involves creating an organizational and cultural transformation, which dissolves barriers between development and operations teams. Through its emphasis on collaboration, automation and continuous delivery pipelines, DevOps allows organizations to deliver reliable software quickly while building shared ownership across development stages.

The article examines DevOps principles at their core and describes their practical implementation within daily workflows, as well as their transformative effects on teams and organizations. DevOps drives both team operational transformation and improved customer satisfaction while fostering sustainable long-term business expansion through continuous improvement.

The Essence of DevOps

DevOps unites software development (Dev) and IT operations (Ops) through practices, which focus on team communication and integration. Under DevOps, operations teams share one continuous pipeline with developers to handle code commits and automated builds, leading to deployment and real-time monitoring. The teams operate as one unit to manage product quality, performance maintenance and system uptime responsibilities.

DevOps practices aim to achieve four primary targets: Streamlining delivery times, enhancing product quality and dependability, enabling rapid feedback cycles and building unified teamwork. The automation of repetitive work processes enables faster delivery times and reduces mistakes, while regular, smaller product releases allow teams to find and fix problems more efficiently. Organizations that align incentives and shared objectives will break free from traditional silos to achieve better results.

Key Goals of DevOps	Impact
Faster Time to Market	Streamlined workflows enable rapid feature delivery.
Improved Quality	Automated testing reduces human errors and ensures reliability.
Shorter Feedback Loops	Frequent releases reveal issues before they escalate.
Collaborative Culture	Teams align around shared objectives for greater cohesion.

Building a DevOps Foundation

Achieving DevOps success demands more than just tools, as it primarily depends on building an environment based on trust and transparency. Organizations undertaking this transformation need to establish cross-functional teams with open communication and continuous learning as their main priorities. DevSecOps teams unite developers with QA engineers, operations specialists and security experts to provide complete coverage from development to deployment and maintenance. Organizations that include team members with diverse expertise enable their workforce to take ownership of all stages, from application development to maintenance.

Besides other practices, blameless postmortems form a core element of the cultural framework. Teams utilize this framework to identify organizational issues and process enhancements, rather than finding human accountability during outage investigations. This approach promotes both organizational openness and create a learning environment based on positivity. The DevOps culture is further reinforced when organizations implement hackathons and internal presentations, enabling teams to learn and adopt best practices together.

Automation and Tooling

DevOps starts with culture, but automation, along with the proper tools, enables teams to execute their principles successfully. A well-designed DevOps pipeline typically includes:

Version Control: Project code management through Git repositories helps teams navigate changes while enhancing teamwork and system tracking.
Continuous Integration (CI): Automation tools like Jenkins and GitHub Actions perform automatic build testing of commits, giving developers immediate results.
Infrastructure as Code (IaC): Through programmatic infrastructure definition, Terraform enables developers to create consistent and reproducible environments.
Continuous Deployment (CD): The deployment process becomes faster with automation tools, minimizing downtime and shortening the time needed to deploy new features to production.
Monitoring and Logging: Platforms like Prometheus and Datadog provide real-time observability, helping teams quickly identify and fix problems.

Key Components of a DevOps Pipeline	Tools and Platforms
Version Control	Git, GitHub, Bitbucket
CI/CD	Jenkins, GitHub Actions, GitLab CI/CD
IaC	Terraform, Ansible, AWS CloudFormation
Monitoring	Grafana, Prometheus, Elasticsearch

Best Practices and Challenges

The process of beginning a DevOps transformation presents overwhelming challenges. Organizations need to start with small pilot projects, both to demonstrate success and to refine processes before expanding their implementation. The success of DevOps depends on complete visibility, as monitoring and logging tools provide shared insights for every team member regarding performance and system issues. Automation of repetitive tasks, including testing and deployment activities, leads to more consistent results and greater operational efficiency. Organizations should view failures as opportunities to learn and use incidents to enhance both their processes and tools.

DevOps offers multiple benefits, yet it faces various implementation barriers. Legacy processes block automation, organizational silos create resistance to cultural transformation and excessive tool usage creates workflow complexity. Companies that tackle these obstacles step by step, while seeking executive backing, will unlock the full potential of DevOps.

Measuring DevOps Success

Strategies that implement DevOps effectively produce quantifiable results, including faster deployments, shorter change delivery times and happier team members. DevOps organizations with high-performance levels deploy features and fixes more frequently, which shortens user wait times. The combination of automation tools minimizes deployment failures, while quick incident response protocols protect the customer experience. Shared ownership, along with continuous improvement practices, results in higher job satisfaction across teams over extended periods.

DevOps represents a permanent shift, combining better collaboration with automation and delivery practices. It unites development teams with operations teams under common objectives to transform work processes. Organizations can foster innovation-driven environments through the right cultural elements and tools, producing enduring value for both teams and end-users.

Conclusion

The technical aspects of DevOps represent only a small part of its transformative power, as this approach creates both organizational and cultural changes that improve team collaboration for software delivery. Organizations that adopt principles of collaboration, automation and continuous improvement can speed up market responses, minimize errors and build a unified work environment. DevOps bridges the development-operations gap by combining cross-functional teams with automated pipelines, uniting operations and development teams under shared ownership principles.

The path to DevOps implementation may encounter obstacles from legacy processes and cultural resistance, but the resulting productivity gains, reliability improvements and motivated team members make the investment worthwhile. DevOps exists as an organic mindset that develops naturally within organizations, rather than being a single standardized solution. The system’s success requires organizations to embrace both the tools and the core principles that prioritize trust, learning and adaptability. Organizations that pursue DevOps adoption will find a tested approach to software development that delivers customer satisfaction, fosters growth and secures lasting achievements.

February 7, 2025

Bridging Creativity and Technical Expertise: How Designers and Engineers Drive Optimal Product Development
In the world of product development, collaboration between designers and engineers is pivotal to creating innovative, user-centered and technically sound solutions. Bridging the gap between these two disciplines, focusing on user experience and aesthetics, and on the other hand on technical feasibility, requires a synergy that can be achieved through effective communication, aligned goals and a commitment to mutual understanding.

Designers and engineers approach problems from distinct perspectives. Designers prioritize the user’s journey, focusing on how a product looks, feels and interacts with the end user. Their work often centers on aesthetics, usability and emotional connection. Engineers, on the other hand, prioritize the technical backbone, ensuring that the product functions efficiently, reliably and within the constraints of available resources.

The success of a product often lies in blending these perspectives harmoniously. Recognizing the value each discipline brings to the table is the first step in fostering a productive collaboration. When both designers and engineers appreciate each other’s contributions, they are better equipped to co-create solutions that are both innovative and practical.

Key Pillars of Successful Collaboration

Open and Transparent Communication
Communication is the cornerstone of any successful partnership. However, designers and engineers often speak different ‘languages’. Designers may use terms like ‘visual hierarchy’ or ‘affordances’, while engineers talk about ‘load times’ and ‘scalability’.
Creating a shared vocabulary is extremely important. Regular team workshops, collaborative design critiques and technical deep dives can help bridge this gap. Tools like Figma and Jira provide a shared workspace where teams can visualize and track progress, fostering a deeper understanding of each other’s constraints and priorities.

Effective communication also requires clarity in expectations. Early in the process, teams should agree on deliverables, timelines and iteration cycles. Establishing these parameters reduces misunderstandings and ensures that everyone is working toward the same goals.

Aligning Goals Early in the Process
Designers and engineers must work together from the project’s inception. Too often, design teams create idealized prototypes that engineers struggle to implement due to technical constraints. Conversely, engineers may develop solutions that fail to resonate with users because they weren’t informed by design principles.

To avoid these pitfalls, I recommend co-creation sessions, where designers and engineers brainstorm together. This collaborative approach fosters a sense of ownership and ensures that both usability and feasibility are considered from the start. Aligning on a shared vision also helps teams avoid costly redesigns and reworks later in the development cycle.

Empathy and Cross-Disciplinary Understanding
Building empathy between designers and engineers is vital. Designers benefit from understanding technical constraints, while engineers gain insights into user-centric thinking. I am an advocate of ‘role-swapping’ exercises, where team members temporarily step into each other’s shoes. For example, designers can participate in code reviews, while engineers can contribute to user journey mapping.

Cross-training also builds respect. When a designer sees the complexity of optimizing algorithms or an engineer appreciates the meticulous thought behind a wireframe, both sides develop a greater appreciation for the other’s craft. This mutual respect is foundational for overcoming conflicts and achieving a balanced outcome.

Strategies for Maximizing Productivity

Leverage Collaborative Tools and Agile Practices
Digital tools like Slack, Trello and Confluence streamline collaboration by centralizing communication and documentation. It is important to use version-controlled design and development tools to maintain consistency and avoid overlapping.

Agile methodologies, such as Scrum or Kanban, are particularly effective in multidisciplinary teams. By breaking down projects into manageable sprints, designers and engineers can iteratively refine their work. Regular stand-ups and retrospectives ensure alignment and provide opportunities to address roadblocks.

Create a Feedback-Driven Culture
Constructive feedback loops are essential for refining ideas and addressing challenges. I recommend implementing structured feedback sessions where both designers and engineers present their progress. These sessions should focus on problem-solving rather than blame, encouraging teams to view challenges as shared responsibilities.

Using prototypes and demos during feedback sessions is especially effective. These tangible outputs allow teams to identify misalignments early and collaboratively refine the product.

Establish Clear Ownership and Roles
While collaboration is critical, too many cooks can spoil the broth. That is why it is important to define roles and responsibilities clearly. For instance, while the designer may own the user interface, the engineer owns performance optimization. Clear boundaries prevent micromanagement and ensure that each discipline can focus on its strengths.

Celebrate Milestones Together
Successes, no matter how small, should be celebrated collectively. Whether it i’s the launch of a new feature or the resolution of a complex bug, acknowledging achievements fosters camaraderie and reinforces a shared sense of purpose.

Despite our best intentions, collaboration between designers and engineers can sometimes face challenges. From my experience, there are usually three common obstacles and ways to address them.
- Misaligned priorities — like the tension between design perfection and technical deadlines — can be resolved by revisiting our shared product vision and agreeing on trade-offs that balance user needs with technical feasibility.
- Tight deadlines are another frequent issue that often forces us to compromise, but I have found that incorporating buffer time into project schedules and focusing on delivering a minimum viable product (MVP) helps us prioritize the most critical features first.
- A lack of leadership support can hinder progress, which is why it is important to champion interdisciplinary collaboration by providing the resources we need, fostering open communication and ensuring that decision-making power is balanced across the team.
Collaboration between designers and engineers is not just a technical necessity but a strategic advantage in today’s competitive landscape. By fostering open communication, aligning goals and building mutual respect, organizations can create a culture where creativity and innovation thrive.

When designers and engineers work in harmony, they can achieve extraordinary results. Through empathy, adaptability and shared ownership, teams can develop products that not only meet technical benchmarks but also fill the needs of their users, a true hallmark of optimal product development.
January 28, 2025
Transforming Productivity: The Intersection of DevOps, SaaS and Remote Work

When you provide software as a service (SaaS), it is important to note that operations are just as significant as development, if not more so. You could have the best features in the market, but customers will leave if the service experiences frequent or lengthy downtime or is riddled with bugs in every update. You need to provide customers with value and do so consistently.

The marriage of development and operations from two disparate silos into what we know as DevOps was a game changer for SaaS. It enabled engineers to build software that they can expand, build upon, scale to accommodate a growing user base and improve based on customer feedback and requests. All team members that comprise DevOps can now synergistically work toward improving service stability and functionality. This transformation in the way SaaS products were developed and updated was like a leap from horse-drawn carriages to modern automobiles.

And now, a new transformation is dawning on DevOps and SaaS, in the form of remote work. It might not be as fundamentally transformative for engineers as merging development and operations, but if remote work isn’t turning the automobile into an airplane, it is at least turning it into a Lamborghini.

Injecting remote work into the equation does not take away from the good that DevOps and SaaS have going for them — we already run everything through the cloud anyway. But we can go on to reap the benefits of remote work, such as having access to a global talent pool — with something as demanding as software, you don’t want to employ just anyone. Moreover, if your product is growing, you would need to expand your team to keep up with it.

There are other benefits like office space cost-cutting or 24-hour workflows utilizing employees from different time zones and more. This is without considering the benefits for the remote employees, such as work-life balance, no commuting or increased productivity (I don’t enter the office without noise-canceling headphones).

That said, a remote DevOps team is a machine that requires a lot of initial setup to run properly.

How to Bring Remote DevOps Productivity on Par or Beyond That of In-Office Teams

The benefits of remote work can be reaped if you use proper tools to facilitate remote collaboration and communication. Software is the glue that holds remote DevOps teams together. Speaking from experience, in addition to the tools used in the office for engineering, version control, testing and deployment, your DevOps team would find it hard to thrive in a remote environment without:

● Team chat software for seamless communication. Written communication goes a long way, but video conferencing is essential. Until VR/AR business tools perfect an actual virtual office space, this is the next best thing.
● Task management software goes without saying. In-office teams can’t do without this either, but for remote teams, you need more comprehensive features like activity logs that don’t expire. It is a big plus if you get something customizable since the whole company will likely use the same solution, so it would need to fit the workflows of all departments, especially the complicated workflow of DevOps.
● Scheduling software is a must. In an office setting, you can see if someone is or if they are currently busy in a meeting or idling away. Working remotely, you don’t have that luxury; but you also don’t want to disrupt your colleagues unnecessarily, so, anything that can reduce friction by openly displaying when team members are available and when they have meetings scheduled is essential. Aside from meetings, I schedule events in my calendar to give myself time to solve difficult problems without interruptions.
● Time tracking software to review progress and performance and identify bottlenecks. Some remote workers shy away from time trackers, thinking of them as monitoring software designed to micromanage employees remotely — it can be if in the wrong hands. But when used properly, it becomes a productivity tool that provides insight into workflow bottlenecks and helps you establish realistic estimates.

Remote Work is Transforming How DevOps Teams Operate in the SaaS Industry

In 2023, the market size of DevOps exceeded $10 billion and its rapid growth is predicted to only continue — remote work being a big factor in this growth. Remote work enables you to populate your team with skilled members than geographic limitations would otherwise allow.

Time will tell what impact this will have on the SaaS industry, but in my experience, remote work has greatly contributed to growth and improved operational efficiency. I can only imagine what kind of SaaS products globe-spanning DevOps teams would be able to conjure now that remote work isn’t such a rare occurrence. The next big SaaS solution is bound to be a team effort from various corners of the world.

December 18, 2024
Unlocking DevOps Mastery: A Comprehensive Guide to Success

In the dynamic realm of software development, achieving mastery in DevOps requires a nuanced understanding of its core principles and a strategic approach to implementation. DevOps is a collaborative approach that combines software development (Dev) and IT operations (Ops) to automate and streamline the software delivery process. It aims to shorten development cycles, increase deployment frequency and deliver high-quality software efficiently.

At the heart of a successful DevOps program lies a trifecta of essential elements: Automation, collaboration and governance. By mastering these pillars, organizations can unlock DevOps’ full potential, accelerating delivery, enhancing reliability and fortifying security.

Enhancing DevOps with Automation

Efficiency is a high priority for IT departments, according to a survey of IT leaders conducted by Rocket Software. Automation is the linchpin of DevOps because it enables organizations – and humans – to streamline workflows, minimize manual intervention, and accelerate software delivery. By automating mundane tasks such as code compilation, testing and deployment, teams can focus on innovation and problem-solving. Automation ensures consistency and facilitates rapid deployment. Ultimately it can enhance efficiency and enable continuous integration and delivery.

However, automation is not a one-size-fits-all solution. To realize its full potential, it requires careful planning, meticulous execution and ongoing refinement. To be effective, organizations must invest in robust infrastructure, tools and frameworks and encourage a culture of experimentation and continuous improvement.

Collaboration: Building Bridges Across Silos

DevOps is about breaking down silos, fostering collaboration, and promoting a culture of shared ownership and accountability. That isn’t about tools; it’s about people. DevOps is as much about culture as it is about technology. Open communication channels, facilitated by collaboration tools and platforms, can help cross-functional teams to work together toward common goals.

Effective collaboration extends beyond the boundaries of development and operations, encompassing stakeholders from across the organization. Every stakeholder has a role in the DevOps journey, from product management to quality assurance to customer support. Each person plays a vital role, contributing their expertise and perspective to the process. Each function is integral to the success of DevOps implementation, whether it’s someone from product management envisioning the roadmap, quality assurance ensuring product reliability or customer support addressing user needs.

Breaking down silos and fostering collaboration among these diverse teams is essential. You need a culture of transparency and inclusivity, where information flows freely and everyone feels empowered to contribute, create and offer opportunities for improvement. In a collaborative environment based on trust, barriers are removed, communication is streamlined and teams are aligned toward a shared goal of delivering high-quality, customer-centric solutions efficiently and effectively.

Governance and Security: Safeguarding the Software Supply Chain

In an era of increasing cybersecurity threats and regulatory scrutiny, governance and security are paramount concerns for organizations embracing DevOps. Integrating robust governance frameworks and security practices into the DevOps pipeline is essential to ensuring compliance, managing risk and safeguarding the integrity of the software supply chain.

From code analysis and vulnerability scanning to access control and identity management, organizations must implement comprehensive security controls to mitigate risks throughout the software development lifecycle. Furthermore, compliance with industry standards and regulatory requirements must be baked into the DevOps process from the outset rather than treated as an afterthought. Moreover, organizations must be vigilant about ethical considerations and algorithmic bias in environments leveraging AI and machine learning, where the stakes are heightened. By embedding security and compliance into every stage of the DevOps pipeline, organizations can build trust and confidence among stakeholders and mitigate potential risks to their reputation and bottom line.

DevSecOps, an extension of DevOps, emphasizes integrating security practices throughout the software development lifecycle (SDLC). Several key security practices and frameworks should be integrated into the DevOps program. These include implementing security automation tools for continuous testing, code analysis practices for identifying vulnerabilities in the source code and continuous monitoring solutions to detect and respond to security threats in real-time.

Additionally, organizations should provide ongoing security training and awareness programs to educate stakeholders about secure coding practices and emerging threats. Compliance with relevant security standards and regulations, container security practices, robust identity and access management policies, secure configuration management and adherence to governance frameworks are also essential. By incorporating these security practices into their DevOps program, organizations can establish a secure and resilient software development pipeline, effectively mitigating the risk of security breaches and protecting critical assets and data.

Mastering DevOps requires a holistic approach encompassing automation, collaboration and governance. By leveraging automation to drive efficiency, fostering collaboration to break down silos, and integrating governance and security to mitigate risks, organizations can unlock the full potential of DevOps and deliver value to customers with speed, reliability and security.

Cultivate a Culture of Learning

However, achieving DevOps mastery is not a destination but a journey — a continuous evolution fueled by a commitment to excellence and a willingness to embrace change. Organizations must cultivate a culture of learning and experimentation, empower their teams with the tools and resources they need to succeed and foster a spirit of collaboration and innovation that transcends organizational boundaries. By embracing these principles and practices, organizations can chart a course toward DevOps mastery and position themselves for success in an increasingly competitive and fast-paced digital landscape.

May 20, 2024
The Evolution of DevOps
In the bustling corridors of the tech world, a revolution known as DevOps reshaped the way software is built and delivered. It’s not just about bridging the gap between development and operations; it’s about fostering a culture of collaboration, innovation and continuous improvement.

Today, DevOps is recognized as a culture of beliefs, practices and principles. As DevOps increases in popularity as the preferred methodology of software development, it’s important to understand how it evolved and what it requires of today’s DevOps engineers.

Evolution of DevOps

Before DevOps became common practice, development and operations existed as two separate components of the application release process. The development team would write code and pass it to the operations team, who would then deploy it to the production environment.

Part of the problem with this process is the tension between what the developers are trying to achieve versus the goals of the operations team.
- Application development pushes for continuous updates to add features, fix defects and make other necessary changes, often as fast as possible.
- IT operations, on the other hand, tries to limit the number of releases as they are responsible for running a stable system with the highest percentage of uptime.
To further complicate matters, there was often no clearly defined or automated process for handing over applications. This would result in miscommunications and misalignments, such as:
- Developers writing code without considering where or how the code would be deployed or passing along poorly-documented deployment guides.
- Operations not fully understanding what they were deploying and why, resulting in inefficiencies. Additionally, any time they would discover issues with the application they would have to send it back to the developers with improvement suggestions.
These situations would cause release delays as operations would struggle with unclear directions or try to resolve unforeseen interactions between the new code and the servers. Server errors could also result in blame games between developers and operations, which would negatively impact company morale. And as this was a continuous process, the development of updates and fixes would continue well beyond the initial launch of an application.

That process began to change in 2007 when consultant Patrick Debois, facing frustrations over the barriers between development and operations teams, looked for a different approach. A meeting in 2008 with software developer Andrew Shafer over “Agile Infrastructure” led to the formation of the Agile Systems Administration Group.

Then, in 2009 Debois watched a livestream of the “10+ Deploys Per Day: Dev and Ops Cooperation at Flickr” presentation from the O’Reilly Velocity Conference. Inspired to host his own event, he launched the first DevOps Days conference in Belgium, which inspired similar conferences around the world.

DevOps quickly gained popularity as companies realized how it could increase efficiencies by:
- Making software development and related operations more reliable
- Reducing the time needed to bring software products to market
- Quickly and effectively delivering software updates
- Improving the culture of work within the organization
DevOps Today

The DevOps mindset changed the culture of software development organizations and evolved into a comprehensive set of practices and principles. DevOps aims to bring both development and operations together by:
1. Shortening the software development life cycle (SDLC) and increasing the velocity with which applications move through the release pipeline.
2. Providing a high level of quality control and ensuring that each update is well tested with a minimal number of bugs or errors.
Today, DevOps engineers have their own role, which often requires a range of technical skills and the ability to work effectively with other teams and departments. Many different methods of rapid deployment and various DevOps toolchains are used across an organization’s development team. These approaches often have different points of emphasis, such as the differing emphases of speed of release, security considerations and user experience between DevOps, DevSecOps and site reliability engineering. For instance, the adoption of microservices architecture. By decomposing applications into smaller, independently deployable services, organizations can enhance deployment efficiency. This allows for quicker iterations and updates and minimizes downtime during deployments, ensuring a seamless user experience. Furthermore, the collaborative culture inherent in DevOps paves the way for faster problem resolution and innovation, fostering an environment where continuous improvement it’s a daily reality. These benefits translate into a competitive edge in the market and drive business growth through technological excellence.

No matter the approach, currently, there are a few consistent sets of best practices for all modern DevOps teams:
- Automation. Automation is a cornerstone of DevOps and affects every stage of the SDLC from infrastructure provisioning to configuration management and testing. By eliminating much redundant manual work, automation can drive down costs and human error.
- Cloud computing. Cloud services provide scalable and on-demand resources, facilitating more flexible and dynamic infrastructure. Use of the cloud speeds developer productivity and efficiency by providing a unified platform for deploying, testing and releasing applications.
- Containerization. Containerization simplifies the process of packaging applications into a single, self-contained unit. Utilizing technologies such as Docker and Kubernetes enables developers to create standardized and portable containers that are deployable across different environments.
- Microservices. The adoption of microservices architecture breaks down large applications into smaller, self-contained services, enabling DevOps teams to develop, test and deploy more efficiently, significantly streamlining the overall process.
- Continuous Everything. DevOps goes beyond the standard practice of continuous integration and continuous delivery (CI/CD) as it also includes continuous testing, monitoring, feedback and operations. By seamlessly sharing insights across various stages, this approach cultivates an ecosystem of relentless enhancement and perpetual progress.
Aspiring DevOps Engineers

There are many professional skills needed to work in DevOps, including expertise in environmental testing, application monitoring and version control. However, true success within DevOps is less about programming skills or managing computing resources but instead comes from the ability to manage extremely complex systems.

In the dynamic landscape of technology, DevOps stands as a beacon of efficiency, collaboration and continuous improvement. DevOps has proven to be a transformative methodology that propels organizations toward a future where innovation, resilience and customer satisfaction are paramount.
January 25, 2024
Fiberplane Adds Open Source Libraries to Automatically Collect Metrics

Fiberplane today added an ability to automatically collect metrics in real-time and make them accessible either via its namesake notebook software for debugging infrastructure or an open source Grafana dashboard.

Fiberplane CEO Micha Hernandez van Leuffen said Autometrics is an open source set of libraries the company created to make it simpler for developers to see platform performance metrics using a set of tools embedded within their integrated development environment (IDE).

The goal is to reduce the cognitive load on developers; today, developers need to first determine what metrics to track, find a way to collect the appropriate data and then launch queries against those metrics to determine the root cause of an issue, said Hernandez van Leuffen.

Autometrics, in contrast, provides access to a set of common queries using the Prometheus programming language (PromQL) against data that has been collected using open source OpenTelemetry agent software, he noted.

That approach, for example, makes it simpler to track error rates, response time and latency of any function. Links to live charts based on real-time data can also be inserted into the comments section of any document a development team creates.

The Fiberplane notebook uses the same operational transformation algorithm embedded within Google Docs to enable teams to easily collaborate around a document or spreadsheet. The core platform itself is built in Rust and WebAssembly (Wasm) to make it simpler to integrate Fiberplane as a plug-in into an existing DevOps workflow.

Autometrics extends that capability in a way that enables DevOps teams to provide developers with instant access to observability data. They can then see how their code is performing on any given platform, which is critical as more responsibility for running applications continues to shift left, said Hernandez van Leuffen. Today, many developers need to wait for an IT operations team to share data collected via an observability platform that was designed to be used by ITOps rather than a developer, he added.

As observability capabilities become more federated across the entire software development life cycle, it’s critical to make sure developers and IT operations teams can see metrics being generated in real-time. Otherwise, confusion arises because teams are not looking at the same set of metrics.

Fiberplane address that issue by taking the concept of notebooks—often used by data science teams to collaborate—and applying it to DevOps workflows to reduce the amount of time it takes to resolve any issue. As IT environments become more distributed in the age of the cloud and microservices, troubleshooting issues invariably spans the responsibilities of multiple members of an IT team. In effect, a notebook makes it possible to spin up a virtual war room on demand that enables the members of an IT organization to collaborate—regardless of where they are physically located or which organization they may be employed by.

April 13, 2023
Tools and Strategies to Drive a Developer Culture of Collaboration

Agile methodologies such as DevSecOps have instilled collaborative habits in many development teams. But developers still struggle to work effectively with other stakeholders in the development process. And hybrid work environments have made collaboration that much more challenging.

In fact, across departments, employees cite collaboration issues among the chief difficulties of hybrid work, recent research shows. Workers experience deficits in team collaboration, working relationships and connection with the organization’s culture.

A key problem for developers is connecting information silos as they interact with quality assurance (QA), site reliability engineering (SRE), product management, and lines of business. Developers need to span their own data chasms, too, as they use a wide range of siloed technology tools. In fact, 68% of developers encounter a knowledge silo at least once a week. It’s no wonder they say their two biggest challenges are fragmented information (46% of respondents) and lack of tool integrations (45%).

There are enough stumbling blocks that your development teams probably aren’t achieving a true culture of collaboration. A culture of collaboration means that collaboration is the default mode of work–with cross-functional teams aligned, team members engaged and productive, and projects consistently achieving desired outcomes.

As much as collaboration is built on human relationships, technology can help, especially in hybrid work environments. In particular, a collaboration platform purpose-built for technical and operations teams is fundamental to building a developer culture of collaboration.

Automation + Integration = Collaboration

Computers are very good at performing repetitious tasks quickly, accurately and consistently. Humans are not. They are, however, well-suited to creative activities and qualitative decisions.

An effective collaboration platform will automate workflows so that software handles rote tasks. Team members are then freed for deep conversations that lead to better decisions and outcomes.

Playbooks are a great way to leverage automation to improve collaboration, and your collaboration platform should include them. Playbooks are essentially digitized checklists that, with a single click, route workflows through predefined steps to complete a task.

For example, it’s not uncommon during development for a code issue to be identified that needs to be escalated for resolution. Typically, this involves redundant texts, emails and phone calls to identify the right decision-makers, plus multiple manual steps for reviews, approvals and status updates across stakeholders and conversations.

That can all be automated in a collaboration-platform playbook. A single click can launch an automated process to escalate the issue to appropriate team members. Workflows take place in the background, quickly and accurately, while developers continue with their collaborations.

But developer collaboration isn’t only hampered by manual tasks. It’s also held back by a lack of integration across software tools. Developers, QA specialists, business analysts and other stakeholders use many purpose-specific technology tools. These range from Google Docs to Microsoft Excel, from Figma to Jira to GitLab. So many standalone products used by so many teams result in capability and data silos.

A useful collaboration platform will unify these tools under a single pane of glass. That way, all team members can continue to work with software that’s purpose-built for their needs, yet all can benefit from integrated access to tools in one context. Combining disparate capabilities in a common context lies at the heart of good collaboration.

Secure and Collaborative

Of course, any development project involves intellectual property (IP) and other sensitive data that your organization must protect. It’s imperative that your collaboration platform provide strong security and access control.

General-purpose collaboration products typically are cloud-based, meaning software-as-a-service (SaaS) offerings hosted by the vendor. That doesn’t always meet the needs of industries such as finance and the public sector that must comply with strict regulatory requirements for data protection.

A collaboration platform for technical and operations teams should offer an on-premises option. That way, you can retain ownership and control of sensitive data.

This level of security does more than simply safeguard your IP. It also encourages collaboration because team members know they can communicate and work together freely without running afoul of internal policies or external regulations. Built-in access controls should ensure that each team has access to the data it requires, but only to the data it needs to contribute to the project.

Digital Tools for Analog Connections

Ultimately, effective team collaboration is built on personal relationships. An effective collaboration platform will encourage human interaction through virtual check-ins, get-togethers and other digitally enabled means of “analog” connection. That could be as simple as providing a rich palette of customizable emojis that allow for personal expression and help to reveal the person behind digital communication.

At a more sophisticated level, project retrospectives should be built into your collaboration platform to evaluate process and performance for continual improvement. Retrospectives should be blameless so all team members can benefit from learnings without feeling censured. A playbook can provide predefined guidance on meeting purpose, scope, timeframe, budget and so on. Approached this way, retrospectives provide an opportunity for team-building and strengthening of personal connections.

Hybrid work environments for developers will continue for the foreseeable future. So will the strategic importance of developer collaboration. A purpose-built technical and operational collaboration platform can help ensure that development teams perform in a culture of collaboration and drive successful application development outcomes.

March 10, 2023

Tag: collaboration

DevOps: Culture and Collaboration

SRE: Engineering for Reliability

Shared Principles and Common Goals

A Unified DevOps + SRE Model

Tools and Practices

Metrics and Measurement

Conclusion

The Core Idea

First Product: Checkpoints

Why This Matters for DevOps Teams

A Crowded Market

The Team

What to Watch

The Essence of DevOps

Building a DevOps Foundation

Automation and Tooling

Best Practices and Challenges

Measuring DevOps Success

Conclusion

Key Pillars of Successful Collaboration

Strategies for Maximizing Productivity

How to Bring Remote DevOps Productivity on Par or Beyond That of In-Office Teams

Remote Work is Transforming How DevOps Teams Operate in the SaaS Industry

Enhancing DevOps with Automation

Collaboration: Building Bridges Across Silos

Governance and Security: Safeguarding the Software Supply Chain

Cultivate a Culture of Learning

Evolution of DevOps

DevOps Today

Aspiring DevOps Engineers

Automation + Integration = Collaboration

Secure and Collaborative

Digital Tools for Analog Connections