►
From YouTube: TT240: GitLab Workshop 2
Description
This is a Tanuki Tech session on 2/5/2021.
For more on Tanuki Tech, see here: https://about.gitlab.com/handbook/marketing/revenue-marketing/sdr/tanuki-tech/
For more on the speaker, see here: https://www.linkedin.com/in/christopher-wang-0835b226/
A
All
right
awesome,
so
thanks
for
attending
today's
session
and
what
we're
going
to
be
talking
about
today
is
a
little
bit
different
than
all
the
sessions
that
we've
been
doing
so
far,
so
in
general,
enablement
at
gitlab.
It's
a
lot
of
reading
stuff,
it's
a
lot
of
watching
videos
and
stuff,
but
one
of
the
things
that's
going
to
be
different
about
today's
session.
Is
that
we're
going
to
see
gitlab
in
action
right,
so
we're
going
to
go
through
a
guided
workshop
in
which
every
single
time
we
talk
to
a
customer?
A
That's
going
through
a
trial,
the
things
that
they
set
up,
the
things
that
they're
getting
up
and
running
we'll
see
a
lot
of
that
and
the
takeaway
points
are
ultimately
how
we
do
things
better
than
our
competitors
and
why
we
did
certain
things.
The
way
that
we
did.
So
it's
a
different
approach
and
ultimately
I
hope
that
this
session
will
increase
our
ability
to
just
like
really
understand
the
product
and
be
able
to
speak
about
it
authentically
and
confidently.
A
A
Right
all
right,
so
new
customer
journey
first
thing
that
they
do
is
very
initial
project
creation
and
configuration
we'll
talk
a
little
bit
about
that.
What
is
what
that
is,
but
surprisingly,
the
second
thing
that
most
customers
do
is
they
set
up
infrastructure?
So
when
we
talk
about
git,
lab
deploying
to
the
cloud
or
deploying
new
versions
of
your
applications,
then
they
need
to
know
where
that
application
is
a
lot
of
new
customers.
Then
do
this
thing
called
configuring
auto
devops?
B
It's
typically
just
like
how
can
we
automate
ci
cd
pipelines
so
they're,
not
usually
using
the
word
like
auto
devops,
but
that's
what
they're
trying
to
do
is
automate
their
pipeline.
So.
A
Yeah,
okay,
awesome
yeah!
So
we'll
talk
very
briefly
about
that.
See
that
in
action
understand
why
it's
important
and
then
other
things
that
will
do
create
an
issue
create
your
own
merge,
request,
watch,
ci,
run
and
then
ultimately
release
new
software.
So
it'll
be
a
good
customer
demo
that
we're
going
through
today.
A
And
the
only
other
thing
that
I
want
to
talk
to
you
pretty
briefly
about
before
we
do
right
in
is
this
auto
devops
thing,
and
this
is
something
that's
really
really
important
to
understand.
So
I
was
a
jenkins
administrator
for
five
years.
I
set
up
all
sorts
of
pipelines
and
stuff
like
that,
and
the
thing
to
really
understand
is
that
with
something
like
jenkins.
A
You
have
to
write
all
of
that
stuff
yourself,
which
may
take
you
between
two
and
four
months
to
really
get
right
and
then
so
for
git
lab
to
offer
something
that
once
you
just
enable
it
by
clicking
a
button
and
for
it
to
set
up.
You
know,
maybe
one
third
of
your
pipeline,
for
you,
that's
really
really
big
for
a
lot
of
customers
because
it
enables
them
to
move
faster.
A
A
There's
like
honestly
speaking,
tons
and
tons
of
tools
that
can
do
a
lot
of
amazing
things,
but
the
problem
is
that
some
of
them
are
so
complicated
that
it
might
take
half
a
year
for
it
to
get
up
and
running,
and
then
what
ends
up
happening
is
that
most
people
install
the
stuff
and
they
never
actually
use
it.
I
was
working
in
a
deal
once
where
a
customer
actually
bought
something
for
seventy
thousand
dollars
and
never
installed
it
because
it
was
too
complicated.
A
All
right
awesome
so
have
you
heard
of
learn,
gitlab.
A
C
A
For
this
one
then
okay,
well
awesome.
This
is
the
demo
of
when
a
new
customer
does
so
just
jumping
through
some
stuff,
real,
quick,
here's,
the
gitlab
ui,
and
the
first
thing
that
we
have
to
do
when
we're
setting
up
a
new
gitlab
server
is
that
we
need
to
create
our
first
project.
So
tell
me
about
the
difference
between
projects
and
groups
like,
what's
the
like?
What
what
do
we
use
projects
and
groups
for
with.
B
C
A
So
a
group
is
like
all
of
our
engineers,
this
one
group
and
then
each
team
is
like
a
subgroup
so
like,
let's
just
say
that
we
can
make
all
of
sales
development
as
one
group
and
then
ramona,
elliot's
team's,
a
subgroup,
hannah
scholler's
team
is
a
subgroup
so
on
and
so
forth.
Now
contrast
that
with
a
project,
a
project
is
a
code
base.
So
when
we
look
at
something
like
this,
all
of
this
stuff
is
a
project.
A
Okay
cool,
so
let's
set
up
our
first
project,
it's
pretty
easy
to
do.
I
just
click
on
this
plus
icon
click,
new
project,
and
then
the
first
thing
that
we
see
over
here
is
that
there's
actually
a
bunch
of
options
over
here.
So
the
whole
goal
of
this
is
that
we
want
to
make
it
so
that
a
new
customer
or
someone
who's
evaluating
gitlab
has
the
best
chance
of
succeeding.
A
Yeah
exactly
so,
if
we
create
from
a
template,
then
this
gives
us
a
bunch
of
the
files
that
we
need
to
get
up
and
running,
so
it
makes
it
very,
very
easy.
All
I
have
to
do
is
click
create
from
project
and
then,
if
it's
a
python
project,
there'd
be
a
python
entry.
If
it's
an
android
project,
it'd
be
an
android
entry,
so
on
and
so
forth.
So
this
just
saves
me
time.
A
If
I
want
to
import
project,
this
is
when
we're
trying
to
steal
other
people's
business.
So
let's
just
say
that
we
have
a
repo
in
github.
We
just
want
to
copy
all
of
that
stuff
into
gitlab.
Well,
that's
that's
just
importing
from
github
right
and
then
so
notice
over
here
we
have
all
sorts
of
different
things
that
we
could
import
from,
and
the
whole
goal
is
that
we
just
want
to
make
it
so
that
people
can
ultimately
migrate
their
stuff
over
to
us.
A
Last
thing
over
here
is
cicd
from
external
repo.
So
this
is
basically
if
you
want
to
continue
using
github,
but
you
want
to
use
gitlab
ci
in
conjunction
with
that
github.
So,
let's
just
actually
do
a
blank
project
here,
I'm
going
to
go
add
in
a
title
for
my
project.
It's
going
to
be
a
simple
app.
It's
going
to
be
a
website
we'll
make
it
a
public
project.
Let's
create
it.
A
And
okay,
great
so,
let's
scroll
down
and
then
now
I
need
to
get
gitlab
to
talk
with
my
local
developer
workstation.
So
what
I'm
going
to
do
is
gitlab
gives
you
all
of
the
configuration
stuff
that
you
need
to
get
up
and
running.
So
it
gives
you
the
text
that
you
need.
A
So
let's
click
over
here
open
my
terminal.
This
is
my
developer
workstation.
All
I
have
to
do
now
is
copy
and
paste
what
it
gave
me
into
my
developer
workstation.
So
let's
do
that.
C
A
Yeah
it's
way
faster
than
if
you
use
github
all
right,
so
we
are
have
our
app
up
and
running
it's
a
simple
app
and
now
we
need
to
have
git
lab
know
about
our
infrastructure
and
the
reason
why
this
is
important
is
because,
if
we're
deploying
to
production,
it
needs
to
know
where
those
servers
live
right.
So
what
we're
actually
going
to
do
is
we're
going
to
add
in
a
server
cluster.
This
is
going
to
be
a
kubernetes
server
cluster
and
as
opposed
to
this
being
super
complicated.
This
might
normally
take
someone.
A
Maybe
a
maybe
half
a
day
to
do
if
they
haven't
done
it
before,
but
using
the
gitlab
ui,
it's
just
going
to
take
them
10
minutes,
and
so
the
whole
idea
is
once
again
streamlining
everything.
So,
let's
click
add
kubernetes
cluster
we're
going
to
specifically
get
one
from
google
cloud.
So
all
we
have
to
do
is
sign
in,
and
so
I'm
going
to
give
this
a
cluster
name.
A
I
want
three
servers
in
my
cluster
and
then
all
I
have
to
do
is
create
kubernetes
cluster,
and
so
now
the
kubernetes
cluster
is
spinning
up.
I
this
is
google
cloud
now
right,
so
gitlab
just
talked
to
google
cloud
cited
and
basically
said:
hey
give
me
some
servers
to
work
with
google
cloud
says:
okay,
here's
your
three
servers
to
work
with
right,
and
so
that
was
super
integrated
super
streamlined,
github
jenkins.
Do
not
do
this
at
all,
and
ultimately
this
allows
us
to
save
a
ton
of
time.
A
A
A
Check
out
on
our
our
cluster
again
so
right
now
doing
just
more.
A
A
So
this
is
another
example
of
us
saving
our
customers
time.
We
just
finished
our
kubernetes
cluster
in
you
know,
google
cloud
and
so
now
to
get
everything
set
up
and
configured.
You
need
to
install
some
stuff
on
the
cluster
so
that
they
really
talk
and
work
together
so
regularly
without
gitlab.
That
might
take
me
one,
maybe
about
one
to
two
days
to
get
right,
but
what
we
did
is
that
we
can
actually
do
everything
simply
through
the
user
interface.
So
over
here,
I'm
in
the
gitlab
ui
I
c.
A
C
A
And
then
here's
all
this
other
stuff,
let's
go
install
ingress,
because
we
need
that,
let's
go
install
prometheus.
We
need
that
too.
Let's
go
install
the
gitlab
runner,
so
I
didn't
need
to
log
into
the
cluster
I
didn't
need
to
muck
around
with
it.
All
I
have
to
do
is
do
everything
to
the
gitlab
ui.
This
is
very
different
from
what
other
people.
A
A
A
All
right,
so,
the
next
thing
that
I
want
to
show
is
how
we
monitor
our
cluster.
So
this
is
the
cluster
health,
some
of
the
dashboards.
This
is
a
new
cluster,
so
we
don't
have
any
data
in,
but
we're
going
to
eventually
stand
up
our
application
and
then
we're
going
to
see
like
these
charts
start
to
fill
in,
so
we'll
go
back
to
this
later,
all
right.
So,
let's
check
out
our
project.
A
And
so
we're
going
to
go
back
from
the
top
developers,
what
they
do
is,
ultimately
they
just
solve
these
tickets
or
issues
all
day,
so
we're
going
to
create
one
real,
quick.
A
A
And
now
we're
gonna
basically
see
this
this
this
issue.
So
this
is
what
we
call
kanban
board.
All
of
your
issues
start
all
the
way
to
the
left,
but
it's
a
visual
representation
of
work.
So
once
things
are
starting
to
get
done,
you
put
them
in
the
doing
column
and
when
they're
closed.
It
goes
in
the
closed
column.
So
that's
how
they
flow.
So,
let's
actually
start
working
on
this,
I'm
going
to
put
it
into
the
doing
column
so
that
someone
else
on
my
team
knows
what's
happening.
A
C
A
And
then,
finally,
let's
make
a
commit.
So
this
is
really
awesome
and
I
want
to
talk
about
what
a
merge
request
is
real
quick.
So
we
can't
just
have
our
code
base
where
anyone
can
edit
it,
because
otherwise
the
most
junior
person
comes
in
and
could
potentially
like
really
mess
things
up
for
us
right
and
then
so
generally.
How
it
works
is
that
you
have
to
have
a
review
process,
and
so
we
don't
just
automatically
edit
the
code
base.
A
We
create
what
we
call
a
merge
request
or
change
request
and
the
whole
idea
is.
I
am
now
making
a
request
to
change
our
code.
I
have
to
now
prove
to
other
people
that
this
is
a
good
idea,
so
I'm
basically
writing
up
something
where
it's
just
sort
of
like
here's
to
change
that
I'm
trying
to
make.
This
is
why
you
should
accept
it.
A
Now
and
check
it
out,
so
all
the
gitlab
automation
is
running
we
didn't
configure.
We
didn't
really
have
to
write
any
of
the
automation
we
didn't
have
to
spend
literally.
This
would
take
us
several
months
to
get
set
up
with
something
like
jenkins,
but
with
auto
devops
like
it's
just
running
completely
automatically
for
us.
So
let's
check
out
some
of
the
automated
jobs
that
are
running.
A
A
So
that
just
built
our
our
this
is
in
particular
something
called
a
container.
So
it's
building
a
container
image
and
one
of
the
things
that
we
do
is
we
actually
store.
The
container
image
too
so
over
here
is
the
container
registry
without
gitlab
you'd
have
to
get
another
server
and
store
it
on
that
external
server.
So
that's
additional
money
for
that
additional
server,
but
with
gitlab
everything's
combined
together.
A
A
A
We're
doing
right
now
is,
if
I
wanted
to
download
this
artifact
into
my
local,
like
computer,
then
I
can
do
that
immediately.
So
that's
what
I'm
doing
right
now,
because
right
now
the
application
save
file
is
on
gitlab.
But
if
I
want
to
get
it
onto
my
local
computer,
then
we
can
do
that
as
well
and
that's
what
we
just
did
here
so
now,
let's
check
out
what
else
is
happening
in
our
pipeline.
A
What
we
just
showed
is
that
gitlab
automatically
built
that
application
file
the
distribution
file
for
us,
so
going
back
into
the
running
pipeline,
you
can
see.
Other
stuff
is
happening
right
now.
A
Let's
check
on
our
merge
request
to
see:
what's
what's
happened
and
let's
check
out
the
the
application
itself,
and
so
this
is
what
we
call
a
review
application.
A
A
This
looks
good
problem
is
I
don't
really
know
what
this
is,
what
this
does,
because
I'm
not
used
to
it,
and
so
it's
really
really
really
hard
to
review
some
of
this
stuff.
If
you
don't
have
the
context
of
what
the
rest
of
this
code
does.
So,
basically,
what
you're
trying
to
say
is
with
something
like
github
you're,
just
reviewing
the
changes
by
looking
at
the
code
changes
with
something
like
git
lab.
However,
we
actually
give
you
a
live
running
version
of
your
application
so
that
you
can
actually
see
the
change.
A
A
So
that's
awesome
that
helps
out
with
our
review.
Now,
let's
check
out
some
of
the
other
stuff.
That's
happened,
so
our
security
results
are
finishing
right
now,
let's
check
out
the
sas
changes
and
then
so
we
found
some
security
problems
here.
This
isn't
something
github's
trying
to
implement
this
right
now,
but
they're
not
nearly
as
good
as
it
as
us,
and
if
you
have
jenkins,
you
probably
don't
have
this.
A
A
A
C
A
It
tells
you
literally
what
part
in
the
application
the
problem
is
happening,
so
it
says
it
has
to
do
with
this
one
web
form,
and
so
let
me
see
if
I
can
go
mess
around
with
it.
I'm
gonna
hit
submit
right
here
and
then
this
result
is
not
supposed
to
happen,
so
I
just
verified
with
my
own
hands
exactly
what
get
lab
found.
A
C
A
B
C
A
A
Now
the
problem
with
that
is
that
we
want
to
sell
gitlab,
which
requires
us
to
have
a
certain
software
license
and
what
you
don't
want
to
do
as
a
business
is
to
want
to
have
a
certain
business
strategy,
but
then
to
pull
in
another
piece
of
software
that
doesn't
allow
for
that.
So
I'll.
Just
give
you
an
example,
let's
just
say
that
you
want
to
run
your
business
a
certain
way,
but
your
engineers
are
just
pulling
in
all
these
different
components
that
one
of
them
requires
allows
for
commercial
use.
A
A
A
Looks
like
I
just
need
to
scroll
down,
submit
the
comment.
A
And
then
let's
merge
this,
these
code
changes.
So
let's
do
that
and
then.
A
So
now
another
pipeline
is
running
in
this
second
pipeline,
which
we
didn't
configure.
We
never
created
it.
We
never
set
it
up.
All
of
this
stuff
was
given
to
us
through
auto
devops
right
and
all
auto
devops
was
was
literally
just
clicking.
A
button
was
we're
going
to
descend
into
this,
and
now
what
this
second
pipeline
is
doing,
is
it's
actually
going
to
change
our
servers
so
that
they
reflect
the
changes
that
we
just
submitted?
A
So,
let's
just
now
that
we're
done
with
our
change,
we
want
to
go.
Do
some
post
change
just
sort
of
like
steps,
so
it's
like
software
is
typically
like
version
2.1,
2.2
2.3,
so
we're
just
gonna
go.
Do
some
of
that
like
post
change
like
clean
up
type
of
stuff,
so
first
thing
that
we're
gonna
do
is
we're
gonna
tag,
our
software
project.
A
So
we're
going
to
call
it
version,
1.0,
it's
pretty
simple
and
then
for
release
notes.
This
is
basically
like
all
right.
What
did
we
do?
Well,
we
updated
the
home
page
right.
We
found
some
security
problems,
but
we
don't
want
to
mess
around
with
it
right
now,
but
this
basically
just
tells
other
people
we
made
these
changes
and
the
reason
why
we
made
these
changes.
So,
let's
scroll
down,
let's
create
our.
A
A
Let's
go
back
to
our
project
and
now
what
it's
going
to
do
is
it's
going
to
automatically
build
out
a
bunch
of
stuff
for
us,
basically
saving
us
a
ton
of
time,
so
we
just
created
our
version
1.0
and
if
someone
else
wanted
to
come
down
out
and
download
our
app,
then
it's
very,
very,
very
easy
for
them
to
do
so
so
check
this
out.
We
can
download
it
as
a
zip
file.
We
can
download
it
as
a
tar
file
so
on
and
so
forth.
A
A
A
A
A
And
over
here
we
have
one
new
server
that
is
running
our
new
application,
so
that
is
really
awesome.
If
I
were
doing
this
with
jenkins,
this
would
take.
I
actually
did
build
this
out
in
jenkins
once
this
took
me
a
couple
of
days
to
build
out
and
gitlab
basically
did
it
for
you
completely
like
automatically.
C
A
A
And
let's
actually
check
out
the
website
right.
So
this
is
the
new
website,
so
we
literally
made
a
change
in
git
lab
and
then
gitlab
automatically
created
a
new
server
running
the
latest
version
of
our
code
completely
for
us
without
me
having
to
really
do
very
much
manually
at
all.
That's
like
the
power
of
gitlab
and
all
the
automation
that
we
give
it.
B
C
A
A
I've
never
seen
a
product
that
you
can
get
things
set
up
as
quickly
as
you
can
using
git
lab.
So
so
the
the
one
caveat
that
I
say
is
auto
devops
isn't
for
everyone,
but
gitlab
in
general
is
still
even
if
you
can't
use
autodevops
like
extraordinarily
efficient
for
getting
things
automated.
It
is
great
at
automating
things,
okay,
so
the
next
thing
that
we
want
to
do
is
we
only
have
one
server.
That's
running
our
application,
let's
just
say
that
we
want
more.
A
C
B
B
A
So
I
just
redeployed
all
using
the
gitlab
ui.
If
we
didn't
have
gitlab,
I
would
be.
This
would
take
a
lot
longer,
but
the
whole
idea
is
that
we
don't
want
our
users
leaving
the
gitlab
ui.
You
don't
need
to
go
use
like
github,
then
switch
screens
contact
switch
to
something
else
and
do
something
by
terminal.
The
idea
is
that
everything
should
flow
in
gitlab
itself
and
so
just
creating
this
new
environment
right
now.
It's
it's
creating
these
new
servers
and
it's
80
done.
Let's
hit
refresh.
A
This
is
something
that's
pretty
advanced,
but
what
this
is
telling
us
is
how
slow
our
website
is,
and
we
had
a
spike
around
10
16
and
it's
gone
down,
and
then
we
can
see
that
this
spike
corresponded
with
the
change
that
we
made,
and
this
is
really
really
important
because
we're
making
changes
to
gitlab
all
the
time-
and
now
we
can
definitively
say
hey
our
website
got
a
lot
slower
when
this
person
made
this
one
change.
A
A
Look
at
some
more
of
the
different
performance
things
that
we
have.
So
how
fast
is
it
running?
How
much
of
our
memory
are
we
using?
Because
sometimes
when
we
make
a
change,
it
will
make
our
application
worse
from
a
memory
perspective
and
sometimes
it'll
make
it
worse
from
like
a
efficiency
perspective
that,
like
is
outside
of
memory,
so
this
is
about.
A
Right
right
now,
what
I'm
doing
is
I'm
actually
I
logged
into
the
server
and
I'm
just
like
messing
around
with
some
stuff
all
through
the
gitlab
ui,
and
so
it's
just
another
example
of
being
able
to
do
everything
through
grit
lab.
I
don't
have
to
go
pull
up
my
local
workstation,
but
I
can
just
do
it
through
gitlab
itself.
A
A
Let's
say
that
that's
a
little
bit
too
aggressive
for
us,
because,
let's
just
say
that
we
had
a
junior
engineer
right
every
time
they
merge
stuff,
we
kind
of
want
to
vet
it
a
little
bit
more.
Otherwise,
maybe
we
could
break
our
website
right,
so
I'm
going
to
go.
Select
this
other
option
automatic
deployment
to
staging
manual
deployment
to
production.
So
what
do
you
think?
The
difference
between
this
is
and
the
first
one.
B
A
C
A
Save
let's
go
check
out
our
ci
cd
again,
so
it's
we
just
changed
it
right.
So,
let's
see
how
things
are.
A
A
So
over
here
you
can
see
all
of
there's
a
bunch
of
like
similar
stuff
right.
What
are
some
some
of
the
things
that
are
different,
I'll,
give
you
a
hint
it
has
to
do
with
these
two
columns.
C
A
A
Approach
all
right,
awesome!
Okay,
what
what
did
you
think
about
the
demo?
Anything
so
surprising,
anything
that
you
know
I
can
help
clarify.
B
A
Yeah.
Thank
you.
The
one
thing
that
I
would
say
about
jenkins
is
that
jenkins
is
a
server
that
automates
jobs,
but
you
have
to
write
a
hundred
percent
of
that
automation
for
you
versus
with
git
lab.
We
give
you
a
lot
of
the
automation
out
of
the
box
where,
after
you
install
git
lab
it
basically
can
start
doing
stuff
immediately.
For
you.
C
A
In
terms
of
us
versus
github,
github
can't
do
a
lot
of
that
stuff
that
we
just
showed
all
of
the
kubernetes
monitoring
all
of
the
attaching
environments
that
stuff
that
it
can't
do.
So.
What
it's
basically
done
is
try
to
get
a
lot
of
actions
to
basically
supplement
and
then
there's
a
lot
of
problems
with
actions,
though,
but
github
on
its
own
can't
can't
do
like
over
50
percent
of
what
we
just
looked
at.
B
Question
are
they
able
to
have
like
plug-in
architecture
that
would
like
give
those
capabilities
which
obviously
it's
another
plug-in.
Something
else
that
could
break
but
is.
Is
there
like
integrations
to
enable
auto
devops
within
github.
A
B
C
A
A
A
If
you
combine
github
with
everything
in
the
marketplace,
they
can
do
substantially
more
than
us,
but
that
being
said,
there's
a
lot
of
problems
with
actions,
so
the
biggest
problem
with
actions
is
exactly
like.
You
said
it's
more
stuff
to
integrate
it's
more
stuff
to
maintain.
That's
exactly
it
and
a
lot
of
people.
Don't
like
actions.
A
Yeah
for
sure,
all
right,
a
couple
of
slides,
left
and
then
wrap
things
up.
So
one
of
the
things
that
I
want
to
talk
about,
real
quick
is
who
does
what?
And
I
think
that
this
is
important,
because
when
we're
prospecting
to
accounts,
there's
all
sorts
of
different
titles
and
sometimes
can
get
confusing,
but
in
general
these
are
the
people
that
are
involved
sort
of
understanding.
What
they
do
is.
This
should
be
a
product
manager,
not
project
manager.
A
I
need
to
update
this
slide,
but
a
product
manager
determines
all
right
3.2
of
our
app.
It
should
have
x,
y
and
z,
x,
y
and
z
turn
into
a
bunch
of
issues,
and
then
so
they
determined
the
course
of
the
product,
and
each
issue
is
like
okay,
I
need
to
go
update
my
home
page.
I
need
to
go,
make
it
faster.
A
I
need
to
go
change
this
button
to
another
color
right,
so
that's
step
one
step
two
is
the
engineering
managers
are
now
responsible
for
getting
all
these
issues
done
and
then
so
they're
the
people
who
understand
okay,
rachel's
really
good
at
this
type
of
stuff.
So
why
don't
we
give
her
all
these
issues
and
sarah
has
been
really
trying
to.
A
A
The
developers
also
review
the
change
requests
and
then
the
devops
engineers
they'll
usually
update
it.
So
our
website
right
and
then
depending
on
the
organization
there's
these
two
people
operations
and
site
reliability
engineers.
These
are
the
people
who
make
sure
that
our
website
is
up
and
running
so
like.
A
What's
the
main
point,
the
main
point
is
that
to
do
what
we
just
looked
at
usually
takes
people
between
five
to
ten
different
tools,
and
so
that's
five
to
ten
different
tools
to
evaluate
to
install
to
configure
to
train
your
employees
on
and
to
integrate
together
and
as
someone
who
used
to
do
this,
this
takes
you
a
lot
of
time
and
so
to
be
able
to
get
everything
in
one
tool
ultimately
allows
you
to
move
way
faster,
and
I
used
to
write
a
lot
of
these
integrations.
A
A
So
we
really
are
unique
in
the
fact
that
we
all
have
an
all-in-one
approach
and
what
we
ultimately
allow
people
to
do
is
to
become
more
efficient
through
automation,
allowing
people
to
break
down
silos
and
save
money.
Just
by
the
fact
that
would
you
rather
buy
10
things,
or
would
you
rather
buy
one
thing?
So
that's
just
bringing
everything
together.