Prior to DevOps application development, teams were in
charge of gathering business requirements for a software program and writing
code. Then a separate QA team tests the program in an isolated development environment,
if requirements were met, and releases the code for operations to deploy. The
deployment teams are further fragmented into siloed groups like networking and
database. Each time ⌚ a software program is “thrown over the wall” to an
independent team it adds bottlenecks.
The
problem with this paradigm is that when the teams work separately:
·
Dev ✌ is often unaware of QA and Ops
roadblocks that prevent the program from working as anticipated.
·
QA and Ops are typically working
across many features and have little context of the business purpose and value
of the software.
·
Each group has opposing goals that
can lead to inefficiency and finger pointing when something goes wrong.
DevOps
addresses these provocations by establishing collaborative cross-functional teams
that share responsibility for maintaining the system that runs the software and
preparing the software to run on that system with increased quality feedback
and automation issues.
A Recurrent Pre-DevOps Storyline
The Dev team that has a goal to ship as many features as possible, kicks a new
release “over the wall” to QA. Then the tester’s goal is to find as many bugs
as possible. When the testers identifies and bring their findings to Dev, the
developers become defensive and blame the testers that are testing the
environment for the bugs. The testers respond that it isn’t their testing
environment, but the developer’s code that is the problem.
Eventually
the issues get worked out and QA kicks the debugged new release “over the wall”
to Ops. The Ops team’s goal is to limit changes to their system, but they
apprehensively release the code and the system crashes. The finger pointing
resumes.
Ops says that Dev provided them faulty artifacts. Dev says everything worked
fine in the test environment. The fire drills begin to debug the system and get
production stable. The production environment isn’t Dev’s and QA’s
responsibility, so they keep hands off while Ops spends all night fixing the
production issues.
Comments
Post a Comment