►
From YouTube: GitLab Demo for DoJ ENRD 2020 03 31
Description
GitLab Federal team members speaking and presenting:
John Mclean
Strategic Account Leader, DoJ
240-506-5528
jmclean@gitlab.com
Darren Rivey
Solution Architect, DoJ
drivey@gitlab.com
Sameer Kamani
Sr. Federal Solution Architect
703-717-1229
skamani@gitlab.com
Bill Duncan
Inside Account Manager, DoJ
202-470-0154
bduncan@gitlab.com
A
My
name
is
Jennifer,
docile
I
am
the
assistant
director
for
the
office
of
information
management.
Had
the
Environment
and
Natural
Resources
Division
of
the
Department
of
Justice
I.
Think
I
am
two
months
into
my
new
job,
so
that
is
where
I
am
at.
If
it's
okay,
I'm
gonna
call
on
people
just
so
that
we
can
kind
of
get
through
this
without
a
lot
of
overlap.
I'm
dead
bird
you're
first
on
my
list:
okay,.
A
C
E
A
F
G
C
H
G
You
could've
asked
the
next
slide
during
please,
so
we
here's
kind
of
like
here's.
What
we
want
to
try
to
cover
today
and
you
know
let
us
know
if
we're
missing
something
or
there's
something
here.
You
don't
want
to
talk
about,
but
we
want
to
talk
about
your
you
know
existing
challenges.
What
your
you
know!
What
what
brings
you
here
today
go
over
your
review
code,
repository
management,
other
things
like
that
and.
D
D
G
So
if
we,
if
I
got
mine
before
like
I,
said
I'm
gonna
do
a
very
short
presentation,
but
I
would
like
to
talk
to
you
guys
a
little
bit
about
you
know.
What's
going
on
over
e
NR
d
and
what's
what's
driving
you
to
to
reach
out
to
us?
And
you
know
what
are
your
challenges
you
just
kind
of
give
us
an
overview.
That'd
be
fantastic.
A
C
Kind
of
provides
a
nice
overview
at
a
high
level
kind
of
where
we
currently
are.
So
you
know
kind
of
the
second
or
actually
just
quickly
going
through
that
we
we
currently
are
practicing
agile,
but
we
have
just
some
preliminary
tools
that
we
had
put
in
place.
So
we
want
to
do
something
to
better
facilitate
the
agile
process
orchestration.
C
So
we
have
some
preliminary
kind
of
a
previous
concept
sort
of
internal,
but
we
would
love
to
be
able
to
have
tracking
in
traceability
throughout
the
process
and
from
a
requirements
gathering
process
perspective
and
want
to
make
sure
that
we
insert
them
it's
a
little
bit
of
an
echo
chamber
at
the
moment.
Yeah.
A
G
G
B
D
C
So
Georgia's
RIT
specialists
and
the
data
management
constructs
so
data
reporting
and
analytics
statistical
analysis.
Things
in
that
nature,
so
I'm
not
sure
what
parts
folks
hurt.
So
I
can
I'll
just
quickly
do
a
very
short
recap,
but
you
know
we're
still
in
our
infancy,
evolving
our
agile
transformation.
So
you
know
we
have
some
an
open
source
tool
that
we've
used
sort
of
internally,
just
to
kind
of
shepherd
that
alone,
but
we're
looking
for
something
more
robust
and
enables
us
for
you
know
for
internal
purposes.
So
we
can.
C
We
can
better
track
the
various
tasks
that
are
within
a
giving
sprint
so
that
we
can
also
do
alignment
from
everything
from
the
the
ux/ui
processes
and
then
from
the
business.
The
BA-
and
you
know
the
requirements
gathering
facets
all
the
way
through
you
know
doing
test
cases
and
then
linking
those
back
to
user
stories
and
things
of
that
nature
and
then
for
Jen
and
I.
You
know
in
the
Supervisory
construct
having
some
rich
analytics
that
we
can
then
share
with
you
know.
C
Our
direct
reports
to
you
know
kind
of
demonstrate
where
we
currently
stand
with
given
projects
we're
also
in
midst
of
putting
in
place
again
as
a
code
repository
so
git
integration
is
obviously
very
very
important
and
we
further
are
extending
from
our
agile
practices
to
to
add
dents
a
coughs
so
that
we're
really
considering
the
privacy
and
security
facets
throughout
our.
You
know:
product
development
lifecycle.
C
So
you
know
we
really
would
like
to
have
a
tool,
that's
sort
of
all-encompassing
to
address
those
needs
and,
and
then
from
the
helpdesk
standpoint
to
the
executive
office
in
which
we
work
are
really
our
core
being
is
to
support
we're
a
customer
service
organization.
You
know
and-
and
we
support
our
attorney
work
for
so
we
often
get
a
lot
of
inquiries
for
for
various
tasks
that
we
support
so
being
able
to
have
some
kind
of
service
desk.
C
You
know,
perhaps
user
facing
and
or
you
know,
integrating
with
with
email,
would
better
enable
us
to
field
the
wide
array
of
requests
that
we
receive
and
and
to
track
them
and
see.
You
know
where
perhaps
we
need
additional
resources
to
to
bolster
our
support
and
to
just
you
know,
operate
as
efficiently
as
possible.
C
You
you
hit
on
you
know
just
looking
at
the
slide
deck
you
know
you
mentioned,
were
we
are
evolving
from
you
know
a
dotnet
back
landscape
with
with
suco
server,
and
you
know
looking
at
more
honor
approaches
such
as
ojs
and
different
databases
that
may
come
with
all
so
I.
Don't
is
that
kind
of
what
you
were
looking
for
and
where
the
overview
yeah.
G
H
C
Was
meant
to
just
be
kind
of
an
initial
entree
into
agile?
We
were
shifting
from
a
waterfall
approach
from
from
several
years,
so
it
was
just
a
you
know
something
to
kind
of
get
us
going,
but
we
we
knew,
it
was
sort
of
a
means
to
an
end.
To
you
know,
a
tool
that
would
better
be
able
to
support
our
growing
growing
shop
and
as
we.
C
H
C
Then,
as
far
as
the
CI
CD,
you
know
again
we're
still
in
our
infancy
with
that
we
actually
it
was
that
get
not
github
that
we've
been
working
with
just
like
in
you
know,
internally
hosted
gift
repo
and
then
for
the
CI
CD.
You
know
still
investigating
tools.
We
had
had
an
instance
of
Jenkins
running,
but
we're
working
together
as
a
team
to
kind
of
figure
out
what
you
know.
Ci
CB
pipeline
may
be
the
best
for
us.
Okay,.
H
C
C
C
Processes,
the
you
know,
ability
to
refactor
the
existing
code
and
modernize
it
and
and
really
making
sure
that
we're
optimal
I
mean
that's
obviously
there
and
then
the
the
complexity.
You
know
dealing
with
the
the
various
you
know.
We
have
some
some
older
technologies,
we're
bringing
on
some
newer
ones,
and
you
know,
complexity
kind
of
is
in
many
numerous
categories,
I
mean
I,
think
they're
all
certainly
relevant.
C
The
other
thing
I
wanted
to
quickly
touch
touch
on
was
you
know,
I
think,
process
and
process
enhancement.
That's
another
big
facet
to
this
too.
You
know
it's
sort
of
refinement
of
our
life
cycle
development
in
all
categories,
so
we
have
content
management.
We
have
you
know,
report
writing.
We
have
just
standard
software
development,
life
cycle,
we
have
testing
life
cycles,
I
mean,
etc.
C
H
G
So
yeah
you
want
to
talk
about
complex,
so
there
is
down
at
the
bottom.
You've
got
ten
stages
of
the
lifecycle,
software
development
lifecycle.
There's
all
these
point
solutions
underneath
that
kind
of
specialize
in
that
particular
area
and
then
you've
got
you
know
different
teams
trying
to
work
throughout
and
touch
each
one
of
those.
It's
a
very
complex
situation
where
and
nobody's
really
tried
to
you
know,
fix
this
and
make
it
an
easier
and
more
seamless
process
until
total
gitlab
came
along
really
were
the
only
ones
that
operate
across
the
entire
lifecycle
go.
A
G
So
you
know
with
with
gitlab,
you
know
we're
in
general,
we
do
concurrent
DevOps
and-
and
it
makes
it
you
know
possible-
for
our
product
development,
QA
security
and
operation
teams
to
work
at
the
same
time
instead
of
waiting
for
handoffs,
which
is
what
you
would
typically
do.
The
teams
can
work
concurrently
in
review
changes
together
before
pushing
to
production,
and
everyone
can
contribute
to
a
single
conversation
across
every
stage.
You
don't
have
to
manually,
configure
and
integrate
multiple
tools
for
each
project
teams
can
start
working
immediately
and
work
concurrently
to
compress.
G
G
G
So,
with
get
lab,
the
review
application
is
spun
up
a
code
commit
before
the
individual
developers.
Code
is
merged
to
the
master
and
the
developer
can
see
in
tests
the
working
application
and
DAST.
You
know
tis,
that's
dynamic,
application
security
testing
and
they
do
that
they
can
scan
the
review
app.
The
developer
quickly,
iterates
to
resolve
vulnerabilities
reported
in
in
the
pipeline
report
and
the
app
sect
team
may
never
see
these
vulnerabilities
because
they
can
be
identified
and
resolved
before
the
code
ever
leaves.
The
developers
desk.
G
G
I
They're
gonna,
it's
all
yours
all
right
so
it'll.
Take
me
a
moment
to
to
transition
here
and
and
we'll
walk
through
what
we're
gonna.
Do
we're
gonna
walk
through
the
workflow.
What
does
it
look
like
to
be
a
developer
to
walk
through
those
steps
and
what
would
it
look
like
for
a
developer
manager
to
give
you
guys
a
sense
of
the
things
that
are
going
on
with
all
those
different
steps
you
already
have
get
get
lab,
sits
on
top
and
what
the
workflow
is.
I
G
I
What
John
said
is
really
important,
because
you're
gonna
see
two
different
web
browsers.
I'm
gonna
stay
in
each
of
the
web
browsers
to
do
my
work,
but
when
I
switch
web
browsers
in
context
which
I'm
gonna
be
going
to
a
different
login,
this
login
here
is
gonna,
be
as
a
developer.
So
let's
take
a
look
at
the
workflow
before
we
start
over
here,
I
wrote
these
things
out
and
so
get
the
developer
workflow.
I
I
Is
it
yeah
I'm,
good,
okay,
good?
Thank
you!
So
we're
gonna,
we're
gonna,
start
working
an
issue
we'll
explore
it
a
little
bit.
If
there's
some
documentation,
we
need
to
put
then
we'll
do
that
we're
gonna
create,
what's
called
a
merge
request.
That's
where
a
branch
from
the
master
will
will
do
the
things
that
we
do
well
we're
working
on
a
merge
request,
which
is
edit
files
staging
commit,
and
then
the
CIC
v-point
client
will
kick
off
an
approval,
no
decay
notification.
I
It's
going
to
go
off
to
a
manager,
there's
going
to
be
some
oversight,
although
all
developers
right
perfect
code,
there's,
never
any
defects
in
it.
It
should
go
straight
out
into
production.
There
is
an
approval
step
that
that's
included
here
as
well,
and
then,
of
course,
there's
some
results
and
surprises
that
could
occur
in
an
automated
pipeline
could
be
everything's
all
green
or
maybe
there's
a
failure,
and
we
need
to
document
that
failure
and
and
have
some
work
on
it.
Those
are
the
steps
we're
gonna
walk
through
for
the
workflow.
I
Let's
start
with
the
issue
board
now,
I'm
gonna
be
the
developer
in
a
for
a
fictitious
company.
Lunch
website
called
tanooki
Tech
and
that's
the
website
we're
going
to
look
at
in
a
moment
after
we
pull.
First,
though,
here's
an
example
of
some
of
the
issues.
This
is
a
small
demo,
our
website,
you
can
see
every
issue
that
we
have
with
thousands
the
issues
on
our
website.
If
you
want
to
see
this
at
scale,
for
this
is
only
a
few
in
here.
I
I
set
a
filter
here
for
a
board
for
me
for
my
work,
so
I
can
find
what
I
need
to
work
on,
and
today
I'm
focused
on
the
doing
column,
I'm
looking
at
what's
the
highest
priority
and
okay
there's
something
right
here.
There's
an
issue
right
here.
For
me
it
was
a
clear
text
password
on
a
webform
that
needs
to
be
fixed.
This
is
pretty
obvious
to
me
that
this
is
what
I
should
be
working
on
out
of
all
the
different
things
that
I
should
be
doing.
I
This
right
here
is
the
one
I'm
gonna
focus
on,
and
that's
the
one
we're
gonna
work
on
right
now,
so
I'm
gonna
click
on
this
issue
and
this
issue,
this
issue
by
the
way,
could
have
come
in
through
a
Service
Desk
request.
It
may
not
have
ended
up
in
the
doing
column
formally,
but
it
could
have
come
in
from
there
and
a
manager
could
have
assigned
it.
So,
let's
take
a
look
at
this.
I
Someone
has
been
very
helpful
when
they
set
up
this
issue.
For
me,
they
pointed
out
which
web
server
or
which
web
form
it
is
that
I
need
to
look
at.
They
also
pointed
out
the
commits
they
didn't
have
to
do
that
for
me,
I
may
have
had
to
have
gone
and
research
that
and
when
I
did,
I
would
have
put
it
in
here
and
added
it
to
the
to
the
notes.
So
with
that,
I
want
to
verify
that
there
is
a
problem
and
I'm
going
to
do
that.
I
Just
by
clicking
on
this
link
and
seeing
let's
see
if
I
can
find
this
now
there
we
go
it
just
popped
up
okay,
so
the
link
was
here
to
show
me
where
the
problem
is
I
want
to
go
verify
before
I
create
a
before
I
branch
and
doing
work
on
it.
So,
let's
see
if
the
password
field
is
really
in
clear
text
and
a
game
I'm
playing
the
role
of
a
developer
for
this
fictitious
company
continuity,
tech
I
will
not
put
it
in
an
email
address
because
that's
not
needed
here.
I
just
want
to
see.
I
I
And,
of
course,
I'm
gonna
attach
my
screenshot,
so
we
go
back
to
desktop
right
here
right
here.
10:33,
so
we'll
add
that
in
a
document
in
today
comment
others
who
can
see
this
like
my
manager,
Jake
or
anyone
else
who
is
actually
this
project,
you
can
see
it,
you
can
see
things
as
I
worked
on
them
can
also
comment
on
it.
Now
that
I've
verified
this
I'm
gonna
go
work
on
it.
I'm
gonna
create
a
merge
request,
and
this
is
where
we
branch.
I
So
this
merge
request
is
typed
back
to
the
issue
automatically
I
don't
have
to
leave
my
web
browser.
I
can
go
and
work
on
this
and
I
have
a
pretty
good
idea.
What
needs
to
be
done
for
this?
It's
it's
fixing
a
field
on
an
index.html
file
and
to
do
that.
I'm,
not
gonna.
Leave
the
the
web
browser
here.
I'm
gonna
use
the
the
embedded
web
IDE.
I
So
let's
take
a
look
at
the
branch
that
we're
working
on
here,
we're
not
on
the
master
we're
on
the
branch.
These
are
the
files
that
are
there.
We're
gonna,
go
look
for
index
dot
HTML
for
this
one
and
we're
gonna
make
a
small
change,
and
then
we
go
look
for
the
password
field
and
where
the
god
password
right
here,
we're
gonna,
make
our
change
so
I'm
making
a
change
on
this
branch.
It's
not
going
back
into
master
there's
a
bunch
of
steps
that
have
to
go
through
first,
a
lot
of
them
will
be
automated.
I
It
saved
the
file
for
me
right
here
in
the
web.
Ide
and
now
I
can
start
the
process
of
staging
and
committing
one
of
the
first
things
to
do
here
is
to
do
a
comparison,
and
just
make
sure
double
check.
Is
that
what
I
intended
to
do?
Is
this
the
diff
that
I
expected
test
or
text
and
password?
Yes,
I
want
the
input
type
to
be
password,
so
that
looks
good
to
me
with
that
I'm
gonna
do
do
this
and
commit
here.
I
can
add.
Of
course
it
always
wants
to
know
right.
So.
H
C
I
Absolutely
absolutely
we're
just
we're
walking
through
workflow
here
it
happens
to
be
on
our
web
ID,
but
like
anyone
who
does
stuff
like
it
there's
personal
preferences,
and
it
could
be
just
with
a
text
editor
and
and
stuff
being
done
by
command
line.
So
if
and
and
so
even
though
you
haven't
seen
this
interface
before
from
from
the
point
of
view
of
get
the
concept
of
stage
and
commit
or
something
that's
you're
comfortable
with
and
familiar
with,
absolutely
okay.
I
I
So
we
always
get
asked
for
the
for
the
commit
message
so
put
that
in
there
it
automatically
fills
it
out
for
us,
but
we
can
put
it
one
that
we
would
like
if
we'd
like
to
do
that
and
we
do
receive
and
commit
now
that
we're
comfortable
with
the
little
files.
Now
the
magic
happens.
The
whole
CICP
pipeline
kicks
off
and
runs
and
we're
gonna
take
a
look.
A
little
look
at
it
here.
A
couple
different
stages
here.
This
is
something
that's
dependent
on
on
the
project.
I
Every
projects
different
might
have
bunch
of
stages
might
only
have
a
couple
stages.
Each
state
might
have
a
couple
different
jobs
in
it,
but
let's
take
a
look
at
this
pipeline,
it
was
kicked
off
for
this
eighteen,
two,
five,
three
we're
gonna
click
on
it.
We're
going
right
in
the
pipeline
and
I
want
to
point
out
a
couple
of
things
here.
One
is
that
the
original
issue
is
right
here.
If
I
like
in
contacts
or
come
back
from
launch
or
so
next
day,
I
need
to
figure
out
what
exactly
originated.
I
This
I
can
click
on
it
and
find
it.
It's
also
tied
to
the
merge
request
to
work
on
and,
of
course,
the
pipeline
that's
running
right
now
and
the
current
status
of
that
pipeline.
So
all
these
things
are
tied
together.
Eventually,
in
a
moment,
a
review,
apps
gonna
be
fired
up
and
we're
gonna
be
able
to
look
at
that
review,
app
to
assess
whether
the
change
was
effective
or
not.
I
I
Oh,
it's
almost
done
by
the
way.
This
is
extremely
short
pipeline.
That's
intentional,
because
otherwise
we'd
be
waiting
for
a
long
time
on
the
call
and
I
wouldn't
be
a
lot
to
talk
about
while
waiting
for
this.
But
in
a
moment
here,
when
this
fires
up
we'll
take
a
look
and
verify
that
the
works
done
now,
it
will
not
go
out
to
the
master
until
it's
approved
and
then
we'll
jump
over
and
take
a
look
at
what
the
manager
sees.
I
No
one.
Let's
do
that
right
now,
while
waiting
for
this,
let's
see
if
we
can
jump
over
there
and
this
one
over
here,
we
have
just
changed
logins,
where
now
it's
another
browser
different
session.
We're
logged
in
as
the
manager
and
the
manager
can
see
all
these
different
issues
and
things
they
can
assign
tasks,
but
they're
gonna
get
a
request
as
soon
as
that
pipeline
kicked
on,
they
got
a
request
to
accrue
we're
gonna.
Take
a
look
at
that
right.
Over
here
is
where
it
is
I
can't
know
where
that
is.
I
We
can
also
look
at
a
merge
request
that
are
specific
for
this
manager
and
that
that's
me
right.
There
all
right
so
here
is
the
merge
request,
and
this
is
the
conversation
that
the
manager
sees
for
oversight.
They
see
it.
The
pipeline
was
successful,
but
the
manual
step
to
clean
up
wasn't
run.
Is
we
still
want
it
there
to
take
a
look
at
there's
an
approval?
I
don't
have
that
button
in
my
interface,
the
manager
or
the
approvals
group
has
that.
I
So
if
the
manager
was
satisfied
here
with
the
with
the
green
checkmarks,
they
could
click
on,
approve
and
there's
a
lot
of
automation
that
can
be
put
into
these
or
they
could
double
check.
You
know
I'd
like
to
just
take
a
look
to
make
sure
that
that
was
done
properly
and
the
review
app
that
we
were
waiting
for
in
the
last
screen
is
available
to
them
right
here
it's
running
alive.
They
didn't
have
to
call
somebody
90
to
turn
it
on
for
them
it's
running
a
live.
I
Let's
take
a
look,
let's
see
if
the
work
was
done,
we
we
know
that
the
work
was
to
change
a
password
field.
Let's
see
if
that
was
done,
it
looks
pretty
good,
looks
like
the
the
task
was
completed
and
if
we
go
back,
we
would
be
satisfied
to
click
on
approve.
If
there's
other
things
that
need
to
be
concluded,
part
of
part
of
this
merger
quests,
we
would
would
take
a
look
for
that,
but
here
were
able
to
quickly
look.
We
could
also
shut
it
down
to
save
resources.
I
I'm
gonna
click
approve
here
and
we're
going
to
jump
back
in
I,
guess:
I
guess
we
could
we
could
jump
back
into
the
back
to
the
developer
view,
but
from
here
after
this
finishes
running
a
second
time
we'll
be
able
to
merge
this
into
the
master
and
then
we're
done
at
this
point.
What
what
are
some
of
the
things
that
come
to
mind
for
for
what
you've
seen
so
far.
C
G
D
I
H
C
C
C
At
the
CLI
level,
you
know
doing
command
line
so
from
the
developer,
I
mean
they.
It's
it's
more
of
an
optional
thing.
Right
I
mean
this
is
this
is
like.
If
they
wanted
to
kind
of
do
a
simple
fix
within
the
interface
they
could.
The
data
would
still
be
there.
However,
if
you
dig
commits
through
whichever
code
repos,
that
is,
that
correct
yeah.
I
So
it's
it's
it's
entirely
possible
to
use
any
web
IDE
for
context
for
cutting
back
on
context.
Switching
though
this
would
be
the
way
to
do
it.
However,
there's
nothing
stopping
a
developer
from
using
you
know,
maybe
if
it
was
something
like
Visual
Studio
code
or
you
know
it
clicks
or
something
like
that.
That's
entirely
possible!
So
there's
nothing
holding,
there's
nothing
holding
back,
they
wouldn't
get
they
would.
I
D
C
I
So
from
manager
from
manager
point
of
view,
there's
a
lot
of
information
here
in
the
merge
request.
There's
the
initial
issue:
there's
the
merge
request
itself,
there's
oversight
and
control
over
whether
something
can
get
merged
back
into
the
master.
There's
the
ability
to
look
at
it
before
it
gets
before
it.
It
gets
merged
and
and
also
other
types
of
things
like.
Maybe
the
security
scanning
like
static
application
and
dynamic
application
security
testing
a
lot
of
different
pieces
in
here
and
also
everything's
everything
is
recorded
and
documented.
I
All
these
steps
are
available
so
that,
if
a
review
app
was
looked
at
a
month
or
two
or
three
months
ago,
that
review
app
could
be
called
up.
The
game
to
me
looked
at
it
doesn't
disappear.
It's
it's!
It's
still
here
to
be
looked
at,
and
it's
all
time
back
to
the
issues
in
the
merge
request
and
the
comments
like
collaborations
that
are
around
it.
So.
I
I'm
gonna
click
on
a
button
that
I'm
gonna
close.
This
merge
request
and
we're
gonna
merge
this
and
we're
gonna
delete
the
source
branch
because
the
information
is
available
without
the
source,
branch,
anyways
and
so
and
by
the
way
this
is,
this
is
being
done
from
a
manager
account
not
from
the
developer
account
so,
and
that
closes
the
emergent
when
this
is
done.
It'll
close
the
merge
request
and
close
the
issue
that
were
originally
open,
and
so
that's
one
of
the
advantages
of
having
a
single
tool
across
the
entire
tool
chain.
H
C
This
is
a
couple
things
that
I
do
want
to
mention
here.
So
in
terms
of
the
overall
presentation
that
Darren
just
did
what
he
presented
was
sort
of
the
workflow
that
the
developer
would
go
through,
which
which
was
kind
of
interesting
in
terms
of
changing
the
code,
and
then
there
was
an
approval
process,
and
then
we
jumped
into
what
he
called
the
manager
role.
I
do
want
to
clarify
a
point
there.
It
doesn't
have
to
be
a
manager
per
se.
It
could
be
anybody
who
is
a
approval
within
the
approval
chain.
C
It
could
be
a
tech
lead
who
wants
to
do
a
code
review
and
approve
something
it
could
be
security
lead
if
they
want
to
do
some
security
review
and
approve
something.
So
all
of
that
is
just
encompassed
as
part
of
that
I
want
to
broaden
the
scope
of
the
approval,
it
doesn't
have
to
be
a
manager
or
it
could
be
any
one
of
those
kinds
of
roles
that
that
could
be
approving
this.
C
The
other
thing
I
want
to
add
is
that
approval
is
completely
optional,
so
we've
kind
of
added
in
the
process
to
prevent
how
approvals
work,
but
you
could
easily
just
turn
off
approvals
entirely
and
not
have
to
do
any
of
that
or
you
can
make
them
optional
approvals,
meaning
that
you
can
have
sort
of
a
code
review
process
where
somebody
is
aware
that
they
need
to
do
something,
but
they
don't
have
to
click
that
approve
button.
They
can
just
say
yeah.
This
looks
good
and
then
they
can
move
through
the
workflow.
C
G
B
I
Once
the
pieces
that
was
asked
about
was
service,
desk
and
so
service
desk
is
possible
and
it
would,
it
would
tie
into
the
into
the
issues.
Part
I
can't
show
to
you
here:
isn't
unabating
bound
email
set
up,
but
the
same
type
of
workflow
could
be
entered
via
an
email
to
inbound
email
to
open
an
issue
that
would
then
be
reviewed
and-
and
you
know,
assigned
and
prioritize,
and
all
that.
G
A
B
B
I
B
C
So
yet
lab
comes
packaged
with
a
git
repository,
a
CI
CD
pipeline
process,
a
delivery
process,
a
Kanban
project
management
process,
as
all
of
that
under
one
application,
which
is
kind
of
what
darren
has
been
showing
I
hope
that
you
were
following
along
through
that
and
and
we're
able
to
see
that
if
not
the
recording
is
there,
and
so
you
can
certainly
review
it
later
on.
But.
C
Within
that
context,
like
there
and
said
you
don't
have
to
start
using
all
of
get
lab
to
do
this,
you
can
use
whatever
you
want
to
and
then
slowly
grow
into
it
if
you
want
to,
but
we
feel
that
if
you
put
everything
in
one
system,
you're
likely
to
get
better
value
out
of
it,
because
your
lacks
context,
switching
you
don't
have
to
eto
number
of
systems.
You
don't
have
to
train
people
on
five
different
interfaces
to
fix
one
problem
that
sort
of
stuff
the.
B
C
Thing
is
yes
to
address
your
question
directly.
Get
lab
CICE
can
be
hooked
up
with
any
get
repo.
So
if
you
have
code
in
a
git
repo-
and
you
want
to
use
git
lab
C
ICD-
that's
fine.
You
can
also
do
vice
versa.
You
can
use
yet
I'm
sorry
get
lab
as
the
git
repository
and
you
can
use
Jenkins
as
the
CI
CD
pipeline.
C
Now
again
generally,
it
is
something
that
we
believe
seeing
how
other
customers
are
seeing
a
lot
of
value
and
putting
it
in
one
place,
because
gitlab
offers
you
built-in
hooks
and
things
like
that.
You're,
not
programming
the
web
hook
and
programming
the
pipeline
and
trying
to
spin
up
like
I,
don't
know
how
many
Jenkins
servers
you
might
have
to
get
something
done.
All
of
that
is
encompassed
in
one
area
and
that's
that's
sort
of
the
value
that
get
that
break,
but.
C
C
C
That
and
we
we
have
pathways
that
we
have
actually
devised
for
a
lot
of
our
customers
to
migrate
out
of
that
architecture
and
structure,
to
get
into
get
world
okay
and
then
be
to
then
start
migrating,
their
groovy
pipelines,
which
is
heavy
coding
into
more
of
a
simplistic
yeah
mo
file
pipelines
there.
And
if
you,
if
you
don't
mind,
do
you
have
a
llamo
file
that
you
can
present
real,
quick
they're
in
like
a
solid
lab
yeah.
D
C
C
H
C
C
Can
do
that
you
could
potentially
even
have
a
Jenkins
job,
so
you
can
have
like
you
can
use
the
Jenkins
API
right
from
here
to
call
out
to
whatever
job
you've
already
done.
So,
if
you
have
investment
that
you
put
into
fixing
Jenkins
just
the
way
you
wanted
to
that's
fine,
we
can
encompass
that
within
the
CMO
file.
So
then
include
all
that
into
here.
So.
C
C
You
can
start
start
migrating
stuff
out
of
Jenkins
into
get
lab
or
keep
it
in
Jenkins
and
just
find
that
right
balance
of
how
to
do
it
and
then
run
is
where
you
then
start
identifying
what
is
taking
really
long
and
then
start
taking
those
components
out
or
really
attacking
them
or
whatever.
So
that's,
that's
generally,
the
pathway
that
we've
done
with
a
lot
of
our
country,
gotta.
I
I
Ahead,
well,
listen,
listen!
Thank
you!
Samir
and,
let's
take
a
look
at
our
merger
quest
and
sewer
rat
I'm
logged
is
the
manager
and
we
were
I'm
gonna
leave
the
page
because
there's
no
changes
I
made
there
go
back
and
you
know
what
I
think
I
already
closed
it
out.
So
we'd
have
to
go
back
to
the
closed
one,
because
I
looked
on
Marge,
let's
see
where
it
went.
I
I
Also
we
did
some
perform
as-salat
too,
and
if
that
was
important,
that's
information
that
would
be
available
here
too,
because
sometimes
you
make
a
change
and
the
performance
doesn't
it's
the
same
as
it
was
before
any
other
chance
to
spot
that
early.
But
this
is
what
the
merger
quest
would
look
like
and.
H
So
maybe
before
we
get
into
the
Service
Desk
aspect,
you
know
I
saw
on
your
web
presence
you
you
have
listed
that
it's
in
sort
of
the
beta
stage
for
the
requirements,
gathering
module
I'm,
just
curious
on
the
roadmap.
How
far
that
so
long,
and
if
you
have
anything
and
maybe
is
a
separate
demo-
but
that's
that's
another
piece
and
maybe
Sanath
could
could
speak
to
some
of
that.
I
C
C
C
Okay,
so
you
know,
but
again
that
that's
going
to
be
shaped
by
whatever
comes
out
of
the
the
analysis
that
they're
currently
performing
with
regard
to
what
needs
to
happen,
the
the
question
I
would
have,
for
you
is
what
what's
your
view
on
the
requirements
management
piece
I
mean
if
you're
doing
some
somewhat
of
an
agile
development,
then
epics
and
epics
and
issues
are
sort
of
kind
of
the
mainstay
there.
But
is
there
a?
Is
there
a
need
for
requirements,
management
type
functionality
that
you're
looking
at.
F
C
Yeah,
so
some
of
that
is
kind
of
natively
present
in
get
lab
Darren,
if
you
don't
mind
with
back
to
the
issues.
Okay,
actually,
if
you
don't
mind
stepping
into
I'll,
tell
you
what
go
to
get
lab.
Comm
/
get
lab
work
web
agent
and
what
we're
here
so
here's
what
I'm
about
to
kind
of
walk
you
through
this
lab
uses,
get
lab.
That's
a
good
line.
Company
uses
the
good
lab
software
to
deliver
and
get
lab
software,
and
it
sounds
kind
of
strange,
but
that's
what
we
do
and
being
part
of
open
core.
C
We
actually
have
our
own
epics
and
our
own
processes
completely
open
for
you
to
peruse
through
now
in
terms
of
traceability,
matrix
right,
so
you've
got.
You've
got
all
the
epics
that
we're
seeing
over
here
there
and,
if
you
don't
mind
clicking
on
the
roadmap,
may
be
best.
Yeah
yeah
and
you've
probably
seen
this
if
you've
seen
the
the
epics.
But
basically
you
can
see
so
it'll
take
a
few
seconds
to
load
the
roadmap,
because
there
are
a
lot
of
epics
that
it
that
it's
trying
to
render
at
the
same
time.
C
But
this
is
the
view
you
get
now,
as
you
scroll
down
you'll
see
that
these
epics
are
in
motion,
how
much
of
the
of
those
epics
are
completed
and
when
they're,
due,
which
is
kind
of
neat
way
to
view
this
thing.
But
then,
if
you
don't
mind
kind
of
clicking
into
Darin,
if
you
don't
mind
clicking
on
a
web
ID
category
strategy,
which
is
a
1
2,
3
4,
5,
6,
7,
yeah
scroll
down
to
and.
D
C
Like
the
seventh,
oh
yeah
right,
there
click
that
other
where
yes,
there
we
go.
Okay,
so
we're
drilling
into
one
of
the
epics
and
what
we're
seeing
is
we
have
the
ability
to
connect
other
sub
ethics
within
this
epoch,
so
go
ahead
and
open
up
one
of
the
top
EPIK
over
there.
The
sub
epic
young,
don't
click
into
it.
Again:
click
the
arrow,
yeah,
okay,
yeah,
sorry,
I'm,
trying
to
talk
fast
and
I'm,
trying
to.
C
We
have
issues
with
in
them
if
you
hover
over
the
icons,
you'll
see
that
they're
open,
so
you
can
kind
of
track
what's
going
on.
But
then,
if
you
scroll
down
a
little
bit
then
and
go
to
like
one
of
the
completed
epics
or
find
an
issue,
that's
completed
and
scroll
down
further,
no,
no
yeah
so
go
to.
You
know:
go
to
scope
labels,
epic,
which
is
like
yeah,
that
one
right
there
expand
or
go
into
it.
Yeah
expand
it
yep!
C
D
C
C
Epic,
but
yeah
go
to
that
one
slip:
levels
with
replacement
logic,
click
on
that
one,
alright
scroll
down
and
what
you'll
see
is
that
merge
request
is
tied
to
this
issue.
So
this
issue
kind
of
defines
exactly
what
is
required.
You
can
see
the
user
story
essentially
right
here
and
then
continue
scrolling
down.
Then
you'll
see
a
merge
request
tied
to
this.
So
you
see
a
bunch
of
merge
requests
right.
C
There
click
on
the
first
one
and
what
you're
seeing
there
is
now
somebody
actually
took
a
piece
of
work
and
actually
did
some
coding
and
changes
and
right
here
in
this
merge
request.
There's
a
couple
things
you're,
seeing
which
brand
was
this
merging
quest
fixed
in
meaning?
Where
did
the
code
end
up
in
terms
of
the
branching
and
when
it
was
merged?
What
the
pipeline
status
was
this
particular
one?
The
pipeline
was
broken
for
the
particular
test,
but
if
you
scroll
down,
you
can
see
the
security
results
of
that
particular
pipeline
run.
C
H
C
As
you
can
see,
everything
is
tied
to
this
thing
right
here
now.
What
you
could
also
have
in
this
one
is
a
job
description
about
testing
and
what
that
job
entailed
in
terms
of
success
or
failure.
So
if
it
had
failed
testing,
it
would
show
up
as
a
failed
job
for
that
testing
until
that
job
passes,
so
that
the
developer
kind
of
works
through
that
process
and
gets
it
to
the
point
where
it
actually
passes
the
testing.
So
what
I'm?
C
What
I'm
kind
of
describing
here
is
the
connectivity,
the
line
of
visibility
you
get
of
a
traceability
matrix
where
you
started
the
beach
with
the
part
of
the
epic
will
drill
down
to
the
issue
and
drill
down
to
the
change.
You
can
actually
see
the
code
so
Darren.
If
you
scroll
up
a
little
bit
and
click
on
the
changes
tab,
you
can
actually
see
the
code
changes
that
were
made,
pull
up
a
little
bit
up
at
the
top
bar,
which
it
changes
didn't.
C
Right
there
yeah
thank
you,
okay,
and
that
shows
you
all
the
changes
that
were
made
and
all
the
files
and
right
here.
If,
if
anybody
wanted
to
do
code
review,
they
could
see
the
code
review
of
things
as
well,
and
all
of
that
detail
is
captured
in
one
place.
So
I
hope
that
kind
of
gives
you
a
little
bit
more
in-depth
view
of
what
you're.
What
you're
asking
for
that
that
can
address
the
question
there.
F
C
C
Yeah,
one
more
go
back
to
the
roadmap
view
that
we
had,
because
that
will
show
you
the
road
map
and
don't
click
on
anything,
don't
go
sorted
by
anyway.
What
I
want
to
show
is
right
up
at
the
top
as
soon
as
it
renders
so.
What
I'll
show
you
is
the
milestones
as
we're
defined.
So,
as
you
can
see
it
right
up
at
the
top
there's
a
milestones
area
and
you
can
see
12.7
12.8.
C
C
So
Darren,
if
you
could
I,
don't
think
those
milestones
are
clickable,
but
if
you
go
into
a
project
and
click
on
the
milestones,
what
you
would
see-
and
we
don't
need
to
do
this
right
now,
but
what
you
would
see
is
a
burn
down
chart.
You
would
see
all
the
issues
that
are
within
that
milestone
and
those
Muslims
are
also
tagged
on
the
issues
themselves.
B
And
this
is
Denver.
I
can
see
it
lab.
You
know
those
folks
that
practice
test-driven
development,
you
know
it's
automated
tests
and
testing
features
out.
There
didn't
have
support
more
of
a
traditional
sense
where
there
are
manual
test
cases
that
would
need
to
be
executed
during
a
sprint.
Is
there
a
place
where
a
repository
of
test
cases
can
be
assigned
to
a
given
sprint
for
regression
testing
or
any
of
those
capabilities
built
in
a
get
lab.
C
So,
no
not
at
this
point
in
time.
No,
so
the
way
we've
approached
it
is
that
we
can't
possibly
try
and
take
on
all
the
different
test
Suites
as
competitors.
So
we
work
well
with
testing.
So,
for
example,
we
have
customers
who
use
selenium
and
in
their
selenium
they've
written
their
test
case
and
the
test
Suites
and
there's
you
know,
conditions
and
all
of
them
log
scripts
and
everything
we
can
link
out
to
selenium
and
we
can.
C
We
can
have
those
issues
within
get
lab
to
show
you
that
that
work
needs
to
be
done,
and
you
know
so.
Somebody
can
actually
track
the
progress.
So
all
of
these
issues
that
are
in
get
lab
don't
have
to
end
up
in
code
anyway.
They
could
just
be
work
items
that
somebody
can
manage
the
project
management
as
visibility
and
then,
according
to
the
process,
you
can
define
exactly
what.
What
who
does
what?
C
So
you
can
find
the
issue
and
say:
okay,
you
know,
Darren
go
run
test
cases
five
to
ten
that
are
in
selenium
and
then
report
back
the
results
on
this
particular
issue,
and
that
way
you
can
kind
of
do
that.
So
again,
if
your
manual,
then
you
you
know
a
lot
of
that
manual
stuff
can
happen
that
way,
but.
D
C
You
start
getting
into
automated,
which
selenium
could
be
taking
to
the
next
stage
where
you
can
put
a
webdriver
on
top
of
it
and
sort
of
automate
a
bunch
of
those
things.
Then
you
can
start
taking
some
or
a
good
portion
of
those
manual
tasks,
automate
them
and
start
including
them
and
get
lab,
and
that
way,
then
you
you're
able
to
do
what
you
need
to
do,
and
so.
D
B
Okay,
yeah
I
can
see
how
that
works
in
a
pipeline,
I
mean
with
with
selenium.
We
have
some
of
that
built
into
our
harness,
so
we
were
thinking
of
running
functional
verification
tests.
You
know
overnight,
because
you
know
they
tend
to
run
longer,
but
we
do
have
a
you
know:
a
QA
individual
that
will
be
creating
test
cases
initially
for
manual
execution
and
as
time
permits.
Certainly
we
would
be
converting
them
over
to
automated
test
cases,
but
I
was
just
more
curious
to
see.
B
If
maybe
there
was
a
view
and
get
lab
that
would
have
a
repository
of
test
cases
where
you
know
you
can
easily
see
them
grouped
together
by
features,
and
you
know
when
a
given
sprint
is
defined,
we
can
kind
of
move
or
link
to
test
cases
that
would
be
executed
as
part
of
the
sprint
see
if
status
of
pass
were
fail
view.
History
of
you
know
how
often
a
test
case
fails
and
so
forth.
H
C
Of
it
can
become
simplistic,
because
once
the
data
is
in
get
lab,
then
we
can
actually
drive
those
those
metrics
and
and
present
that
and
something
that
unfortunately
I
think
because
of
timing
right
now,
we're
not
able
to
show
the
analytics
dashboard.
So
we
do
have
those
dashboards
which
key
awful
issues
and-
and
the
other
thing
that
Darren
mentioned-
was
labels
on
the
issues.
C
So
you
can
actually
tag
the
issue
with
a
specific
type
of
label
and
you
can
say
manual
QA
or
something
like
that,
and
then
you
can
run
the
report
based
on
that
to
see
you
know
how
many
were
done.
They
may
be
their
sprint
and
how
many
had
passed
I
may
tell
you,
can
sort
of
do
those
metric
analysis
with
that
I.
B
F
C
I
C
C
C
Is
we
have
a
design
management
capability
within
get
labs?
So
within
an
issue
you
can
actually
incorporate
some
images
that
are
like
wireframes
and
things
like
that,
and
they
remain
as
part
of
that
and
that's
part
of
the
design
management
capabilities
that
we
have.
You
can
actually
version
control
them.
You
can
actually
see
them
and
share
with
them
within
the
context
of
that
particular
issue.
That's
being
worked
on.
E
E
C
Yeah
yeah,
so
there's
couple
things
there.
The
first
thing
is
that
you
can
instrument
your
developed
app
with
the
Prometheus
data
collection
mechanism.
We
embed
Prometheus
as
part
of
the
gitlab
architecture,
and
you
collect
metrics
and
information
that
you
know
whatever
information
that
you
want
to
collect
out
of
your
application
and
then
graph
on
ax
is
sort
of
a
dashboard
in
capability,
and
we
can
certainly
do
another
deep
dive
call
if
you're
interested
in
those
kinds
of
things
where
you
can
actually
visualize
that
data.
C
So
if
you're
interested
in
Kalama
tree
of
some
sort
where
you've
got
a
certain
fee
set
of
features,
you've
developed
and
you
want
to
see
how
your
users
are
using
that
you
know
by
embedding
those
Prometheus
data
collectors,
you
can
actually
pipe
that
data
into
the
Prometheus
database,
which
is
like
I,
said
embedded
within
the
good
lab
architecture.
And
then
you
can
drive
the
the
dashboarding
of
it
to
Ravana.
H
B
More
than
Berlin
yeah
this
is
this
is
Denver
from
our
applications
perspective.
We
mainly
deal
with
intranet
applications
and
we
currently
don't
have
any
instrumentation
built
into
our
applications,
but
we
utilize
Google
Analytics
as
well,
but
that's
some,
that's
a
path
that
we're
looking
to
be
built
into
our
applications
is
more
metrics.
As
far
as
how
users
utilize
our
applications.
C
C
E
G
Either
we
could
either
you
know,
keep
going
for
a
little
bit
or
we
could
we
could,
and
at
this
time
and
in
regroup,
you
guys
get
to
just
this
a
little
bit.
It
might
be
a
good
idea
for
us
to
focus
in
a
little
bit
more
on
your
on
your
use
cases
for
another
call
and
see
how
we
fit
in
to
your
process
or
your
desired
processes
and
just
know.
A
A
G
G
G
You
know
we
just
had
a
lot
of
different
things
that
we
didn't
do
as
one
integrated
toolset
and
the
iPhone
came
along,
and
we
we
substitute
a
lot
of
stuff,
and
we
use
that
for
a
lot
of
things
that
we
used
to
do
with
individual
tools
now
does
does
the
iPhone?
Is
it
the
best
at
everything?
It's
not
the
best
at
every
single
thing.
It
everybody
knows
that,
but
it
is
convenient
enough
to
to
use
it.
G
G
G
J
Like
I
had
one
thing
John
or
the
DOJ
team
in
the
meantime,
if
you
look
in
the
chat
window,
I
did
host
the
narrative
for
the
art
direction,
for
requirements,
management
and
also
on
the
accessibility
testing.
The
first
iteration
of
that
was
in
February's
release
and
there
is
the
DES
blog
that
followed
by
one
of
the
developers
of
it.