►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Yeah,
so
so
I
wanted
to
just
kind
of
think,
because
alessia-
and
I
chatted
quite
a
bit
earlier
this
week-
one
to
one
about
rollbacks-
and
this
is
so
tied
in
so
maya
when
we
were
chaining
one
to
one
about
the
post-deployment
migrations
and
next
steps.
A
It
was
like,
let's
just
come
together
and
work
out
so
rough
thing
that
we
kind
of
need
to
decide
is
the
immediate
thing
to
decide
is
what
are
the
next
steps
for
rollbacks
around
post-appointment
migrations,
but
if
we
can
decide
on
where
we
wanna
like
head
in
the
future,
then
hopefully
that
stuff
comes
together,
so
that
was
kind
of
my
sort
of
intentions
behind
this
sink.
A
So
yes,
thanks
for
putting
all
the
stuff
in
the
agenda
myra
so
based
on
what
we
have.
Currently,
we
have
option
a
and
option
d
I'll
call
it
h
the
a
per
c
option
mentioned.
So
do
you
want
to
run
through
all
the
stuff
you've
got
in
the
agenda
mira
like
or
do
you
want
to
just
discuss
like
have
that
as
reader?
Your
choice.
B
There
is
uncertainty
and
we
also
don't
know
what
kind
of
operations
are
they
going
to
execute,
and
we
also
have
other
details
about
the
long
execution
of
large
intersections
that
are
going
to
block
production,
the
manual
production
deployment
against
the
automatic
creation
of
the
post-economic
migrations.
B
Instead,
it
seems
that
we
really
need
to
exert
control
over
the
post-employment
migrations,
and
that
is
when
option
d
comes
around,
which
is
basically
the
combination
of
option,
a
removing
the
post-employment
migrations
from
the
coordinated
pipeline
and
option
c,
which
is
executing
both
deployment
migrations
in
a
specific
guidance
and.
B
The
possible
migrations-
I
think
this
is
a
very
long
term
and
gold,
like
we
were
talking
with
amy
about
this-
is
kind
of
the
holy
grail
for
post-deployment
migrations,
and
I
think
the
execution
should
be
based
on
the
content
of
the
post
deployment
migrations
and
I
also
put
some
examples
like
for
for,
for
example,
a
large
indexes
or
long
foreign
keys.
B
They
should
be
created
like
in
low
traffic
or
even
in
the
weekends,
or
we
kind
of
we
can
set
a
schedule
based
on
that
data-
migrations,
for
example,
that
are
not
critical
or
very
smart,
the
shirt
they
could
be
executed
daily
and
also
like
adding
columns
removing
columns
they
can
also
be
executed
daily,
but
we
really
need
to
identify
and
signal
the
content
of
possible
vibrations.
B
So
we
can
pick
and
schedule
based
on
that,
and
as
I
said,
I
think
this
is
something
that
we
can
achieve,
but
it
is
a
long-term
effort.
I
don't
see
I
visualize,
I
don't
know
I
I
don't
want
to
be
positive
or
something
but
or
negative,
but
probably
a
couple
of
quarters
into
this.
I
don't
think
this
is
something
that
we
can
achieve
within
a
month
so
to
speak
and
well.
I
think
I
am.
I
am
thinking
it
at
least
two
iterations
for
this.
There
can
be
more.
B
B
So
the
execution
will
be
at
the
discretion
of
the
release
managers,
because
it
would
basically
depend
also
on
the
release
schedule
and
also
on
the
outcome,
availability
and
then
option
iteration,
two
or
yeah.
It
will
be
to
make
the
execution
of
the
pos
deploy
migration
smarter.
A
D
I
came
to
this
meeting
with
a
mindset
of
discussing
some
specific
things
related
to
rollbacks,
but
then
my
attention
got
distracted
by
reference
of
your
issue
into
another
one,
which
I
linked
at
the
very
bottom
of
this
agenda,
which
kind
so
I
was
reading.
This
comment
comments
and
this
kind
of
opened
my
mind
and
one
of
the
options
that
we
kind
of
disregarded
at
the
beginning,
which
is
not
using
post
deployment
migration
at
all.
D
So
I
I
I
don't
care
about
the
details
of
the
that
g,
whose
specific
thing
it's
out
of
scope
for
what
we
are
doing,
but
there's
a
point
in
what
camille
is
saying,
which
is
very
on
top
of
everything,
which
is,
we
should
focus
on
what
the
pro
the
framework,
how
first
and
avoid
monkey
patching
and
creating
stuff
on
top
of
that
positive
migration
are
a
trick
built
on
top
of
on
the
framework
because
they
are
not
supported.
D
So
if
we
have
to
think
about
long
term,
I
would
like
to
think
about
long
term
without
post
development,
migration
and
rethinking
user,
not
really
usable
administrative
control,
because
there
are
plenty
of
web
software
around
that.
Don't
have
post
deployment
migration,
I
mean
they
have
they
don't
have
how
we
implemented
them
right,
so
it
was
kind
of
a
trick
for
giving
this
for
monthly
releases
so
that
we
can
do.
D
Basically,
we
have
a
synchronization
point
after
the
installation
complete
so
that
we
can
run
positive
migration
when
everything
else
is
upgraded,
but
there
is
a
point
which
there
is
a
pattern
that
I've
seen
in
other
software
web
software,
which
is
running
post
deployment
migration
through
the
admin
panel.
So
in
the
admin
panel
you
have
a
kind
of
a
warning,
a
notice,
a
list
of
things
requiring
your
let's
say
as
an
administrator,
your
immediate
action
or
you
have
to
just
pay
attention
to
them.
Oftentimes.
D
These
are
running
indexes,
restructuring,
post
deployment,
migrations
and
things
like
that.
D
Probably
we
reach
the
level
of
maturity
where
we
should
think
about
that
type
of
interface.
Instead
of
this
post
development
thing,
then
we
can
still
have
an
api
call
for
running
them
right.
So,
in
the
end
we
can
still
have
for
customers
who
wants
packages
that
at
the
end,
they
just
call
the
the
api.
But
this
kind
of
moves
these
things,
because
there's
no
longer
expectation
for
the
migration
to
run
immediately
after
or
at
any
point,
they
just
are
there
and
the
admin
should
run
them.
A
D
A
A
B
Yeah
just
before
that,
I
think
yes
definitely
opinion
migrations
are
tricky
and
a
future.
Without
them,
I
think
it
would
be
brighter
than
the
one
we
have
now.
I
think
this
proposal
of
trying
to
make
the
execution
smarter
will
get
us
closer
to
execute
like
even
long
batches.
B
B
B
D
B
Yeah
yeah
something
to
consider
that
we
can,
it
would
be
lovely
to
have
a
bottom
in
the
administrative
tool,
but
okay
run
it
now.
That
would
be
great,
but
I
think
we
need
to
think
about
how
to
remove
the
complexity.
A
A
We
should
keep
in
mind
whether
the
first
step
is
just
to
work
out
what
types
we
have
and
frequency,
and
how
long
do
they
tend
to
run,
because
it
might
be
that
some
of
them
are
easy
to
solve
either
like
you
know,
we
may
have
one
that
only
runs
once
a
month
easily.
We
can
just
deal
with
that
versus
one.
That's.
You
know
three
times
a
day
type
of
thing,
so
it
might
be
that
before
we
actually
make
a
firm
decision,
we
want
to
just
find
out
those
numbers.
D
D
Yeah
so
yeah,
because
we
so
we
did
point
one
red
right,
so
mira
was
reading
to
it.
So
we
are
there.
So
my
point
here
is
that,
because
now
we
are
work,
we
are
working
on
this
metric
for
showing
pending
migrations,
which
is
in
review
so,
but
there
is
a
missing
information
here
which
is
packaged
to
migration.
D
So
let
me
try
to
explain
this
with
an
example,
so
we
have
several
things
that
are
moving
independently.
When
we
release
we
can
tag
we
can
deploy,
we
can
do
certain
things,
then
we
can
run
the
pos
deployment
migration
and
we
may
be
willing
to
roll
back
at
certain
point
right
so
right
now
we
have
the
easy
information
which
is
a
package
is
not
world
backable,
because
it
includes
positive
alignment,
migration
compared
to
the
previous
one.
D
So
this
is
a
simple
check.
Then
we
know
that
many
of
those
possible
immigration,
maybe
are
rebeccable,
but
we
just
say
there
are.
There
are
cases
where
this
can't
be
rolled
back,
so
we
we
don't
roll
back,
that's
what
we
have
right.
If
we
remove
branding
post-deployment
migration,
we
may
think
we
start
thinking
that
we
can
always
roll
back
up
until
the
last
time.
We
run
the
positive
problem
migration,
but
then
there's
a
missing
information,
which
is
when
we
run
those
post
deployment
migration
from
from
which
package
are
they
originating
from
because
this?
D
D
D
You
say:
oh,
it's,
the
20th.
We
want
to
the
pick
a
stable
branch,
so
let's
run
post
deployment,
migration
and
maybe
something
that
could
have
been
spot
one
day
ahead
of
time.
It
really
depends
on
how
often
we
run
them
right,
but
let's
say
one
head
have
a
time.
Then
it
will
kind
of
slip
into
the
let's
say
the
rc42,
and
then
we
have
to
figure
out
if
this
was
related,
so
it
adds
it
makes
harder
to
think
about.
D
D
Because
I
don't
want
that
we
are,
I
would
like
to
avoid
going
into
a
state
where
what
we
built
in
terms
of
confidence
for
the
rollbacks
we
kind
of
it
goes
away,
because
we
have
this
uncertainty
around
positive
alignment
migration.
D
So
we
should
probably
try
to
think
a
couple
of
scenarios
and
building
some
timelines,
because
I
mean
it's
a
matter
of
having
a
timeline
and
thinking
if
things
can
get
past
the
point
or
not
right
so,
but
we
we-
we
haven't
done
this,
because
we
were
more
focusing
on
the
social
aspect
on
how
to
change
this
and
make
making
this
so
that
is
kind
of
developer
friendly,
more
slender
than
just
say.
D
You
can't
merge
that
thing
or
you
have
to
split
your
merge
requests,
but
basically
because
we
are
doing
this,
making
it
easier
for
them.
We
are
making
harder
for
us.
So
we
need
to.
We
can
shoulder
the
the
extra
complexity,
but
we
need
to
make
sure
that
we
we
thought
about
it
so
that
yeah
that's
my
point.
B
Yeah,
I
hope
hardly
agreeing
with
about
the
complexity
that
is
adds
to
release
managers,
because
we
need
to
know
we
need
to
have
visibility
about
if
we
have,
pending
both
deployment,
migrations
and
the
type
of
them
right.
We
need
to
know
if
we
are
going
to
execute
a
background
and
we
are
going
to
create
an
index
to
a
high
traffic
table
or
an
index
to
a
regular.
B
Take
that
much
and
we
really
need
to
have
that
information
somewhere,
whether
it's
a
slack
command
or
a
final
dashboard
like
a
post
deployment,
migration
pressure.
We
need
to
have
that
information,
something
because
that
will
allow
us
to
take
a
decision
from
them
and
when
it
comes
to
piling
up
those
first
starters,
we
will,
I
think,
and
I'm
speaking
for
experience,
that
we
have
around
five
packages
a
day.
I
think
from
experience
I
would
say
yeah
one.
At
least
one
of
those
packages
has
a
single
pole
deployment
migration.
B
B
Awesome
but
one
on
those
three
packages
might
have
a
post
development,
migration
right
sure
and
those
can.
Those
can
be
executed,
mia
or
number.
So
we
will
need
to
make
sure
that
this
independent
job
is
executed
at
least
once
a
day.
So
it
doesn't.
So
it's
not
that
different
from
the
execution
that
we
have
today
and.
B
I
I
forgot
what
I
was
trying
to
say,
but
yeah
visibility
execute
the
possible
migrations
once
a
day.
A
A
So,
just
to
step
back
a
little
bit
before
we
go
into
to
this,
like
what
do
we
in
terms
of
the
because
it
sounds
like
the
the
trickiest
part
of
all,
of
this
is
going
to
be
the
the
kind
of
the
the
maybe
the
short
term
right,
the
first
situation
before
we
have
tooling
and
things
so
in
terms
of
like
the
long
term.
Do
we
are
we
aiming
for
having
no
post
appointment
migrations
or
are
we
aiming
for
them
running
on
their
own
independent
schedule
based
on
the
type
of
migration?
A
B
Will
be
now
yeah.
B
D
C
D
D
Yeah,
but
if
I
I
do
agree,
but
before
we
push
it
to
the
product,
which
means
that
we
classified
and
identified
types
of
migrations,
so
I
would
long
term
we
already
identified
if
some
of
this
are
of
a
certain
problem,
I
kind
of
expect
that
most
of
them
will
be
signed
up.
Some
kind
of
cleanup
state,
so
cleaning
up
means
that
we
just
waited
a
long
time
to
make
sure
that
the
version
bumpings
and
things
like
that-
don't
mess
up
with
this,
so
it's
kind
of
removing
columns,
so
we
can
run
them.
D
There's
no
problem
and
the
other
one
is
background
migrations
top
of
my
head.
Maybe
there
are
others,
so
I'm
just
thinking
index
creation,
background
migration,
things
like
that,
so
if
they
are
part
of
the
product,
I'm
expecting
that
we
will
have
administrative
api
around
this
one.
So
we
can
kind
of
it
will
go
back
to
be
our
problem,
but
is
it's
a
well-defined
problem?
D
It
is
no
longer
this
black
box
where
things
happen,
takes
eight
hours
10
hours.
We
don't
even
know
what
is
happening
inside
and
if
you
go
down
the
route
of
defining
this
at
the
product
level,
there's
no
longer
this
positive
migration
failed
to
run,
but
you
have
single
units
of
work.
So
maybe
you
have
you
you
have
to
think
about.
Can
I
reschedule
this?
What
does
it
mean
if
this
failed?
D
It
really
forces
you
to
push
to
through
the
definition
of
what
is
this
type
of
job,
and
so
you
have
to
think
about
also
failure
in
the
product
and
not
just
I
run
positive
migration.
They
crashed,
but
this
is
super
long
term.
A
So
the
reason
the
reason
I'm
asking
this,
though,
is
I
think
so
what
we're
talking
about
with
this
kind
of
mid-term
solution
of
pulling
them
out
a
lot
of
the
challenge
is
going
to
be
around
the
scheduling
and
the
visibility.
A
So
like
the
big
challenge
I
see
of
separating
these
out
of
the
of
the
pipeline,
as
we
have
today
is,
should
I
mention
in
2d,
so
we
have
the
whole
point
that
alessio
was
just
making
about
how
far
back
can
we
roll
back
to,
but
we're
also
going
to
have
a
lot
of
visibility
that
we
need
around
incidents,
because,
whilst
these
things
are
running,
if
we
have
an
incident,
it's
not
going
to
be
so
clear
to
link
like.
Oh,
this
job
is
running
versus
what
we
currently
have.
A
So
we
will,
if
we
do
this
short
term
and
just
pull
them
out,
we're
going
to
need
to
do
some
work
around
visibility.
A
It
might
be
worth
thinking
about
whether
that
is
whether
that's
the
right
first
step.
If
our
long
term
is
quite
a
different
solution,.
E
B
B
D
You're
right,
I
just
want
to
give
you
a
quick
example
for
for
a
possible
idea
for
rolling
back
stuff,
so
removing
column
is
impossible.
There's
no
way
around
that
because
you
have
to
ignore.
If
you
want
to
roll
back,
you
have
to
ignore
them,
so
that's
impossible
and
I
wouldn't,
but
it's
kind
of
uncommon.
D
I
I
think
that
the
one
of
the
biggest
problems
we
have
with
rollbacks
are
background
jobs,
because
when
you
roll
back
you're
removing
the
class,
the
the
worker
that
is
implementing
the
operation,
but
the
data
is
still
on
it's
in
redis,
so
redis
is
trying
to
crank
to
get
out
the
jobs
and
then
can't
create
the
class
because
it's
not
there.
D
So
this
is
kind
of
an
easy
thing
to
solve
right,
because
you
you
can
write
already
smith
word,
try
to
figure
out
if
something
like
this
is
happening
and
just
stop
processing
those
cue.
D
Fish
reflect
things
around
them,
so
you
can
kind
of
have
an
admin
in
control.
Where
you
say
I.
I
want
to
stop
processing
this
type
of
jobs,
so
you
know
you're
going
to
roll
back
to
stop
the
thing
and
they
will
just
sit
there
in
red,
so
they're
I
mean
we
can
think
about.
But
the
point
is
that
we
first
need
to
figure
out
what
type
of
why
we
are
using
post
deployment,
migration.
B
Yeah
yeah.
Returning
to
the
background
migrations
point,
we
have
the
steel
metal
that
allow
us
to
steal
them
and
remove
them
from
the
cube
and
when
we
want
to
roll
back-
and
it
is
a
bit
more
complex
background.
Migrations
are
super
complex
and
this
might
be
part
of
another
discussion.
But
if
we
want
to
roll
back-
and
we
have
a
short-lived
background
migration-
we
if
this
one
already
finished,
we
can
roll
back,
because
there
is
no
pending
jobs
and
the
code
should
be
independent
from
the
application
code.
That's.
D
D
That's
one
of
the
reasons
why
we
have
these
things
right
because
we
released
monthly,
so
you
can
just
instead
of
splitting
this
type
of
operation
over
two
milestones.
You
can
do
it
in
one
because
you
can
do
if
the
database
has
this
column.
This
column
is
valid
as
value
then
read
from
here.
Otherwise
go
there,
but
but
this
is,
this
is
kind
of
a
wrapper
code
that
you
have
around
accessors
on
on
columns
and
things
like
that.
Then
you
remove
on
the
next
release.
B
Yeah,
but
that
is
the
case
when
you
process
something
and
you
remove
information,
but
there
might
be
a
case
in
which
you
also
object
to
something
and
you're
adding
data,
and
that
should
be
fine.
So
it
really
depends
on
the
background
migration
and
we
really
need
to
classify
them
and
to
understand
what
they
are
doing,
because
we
don't
know.
A
Okay,
so
in
terms
of
rollbacks
that
yeah,
this
is
complex.
So,
okay,
so
we're
saying
that
we
want
to
split
these
out
and
have
them
run
manually
and
we'll
assume
it'll
be
once
a
day
and
the
release
manager
would
organize
that.
Okay,
so.
D
D
So
the
first,
let's
say
first
step
very
easy,
not
not
very
say
not
not
complete,
but
is
that
when
we
run
post
deployment
migration
we
store
somewhere
the
package,
so
we
know
that
we
can
roll
back
up
until
that
point.
This
is
not
entirely
correct,
because
maybe
that
package
has
no
new
post
deployment
migration.
They
were
just
coming
from
the
previous
one,
just
an
example
right.
So
we
are
stopping
the
window
of
a
rollback
but
ins,
but
maybe
we
could
go
extra
package
back.
We
don't
know
so,
maybe
second
step
we
can
do.
A
So
for
now,
if
we
did
that,
that
gains
us
quite
a
lot
in
rollbacks
right.
So
not
always
it's
going
to
depend
a
bit
on
luck,
but
hopefully
you
would
be
able
to
roll
back
four,
maybe
five
packages
if
needed,
which
is
going
to
be
way
better
than
a
probable
one
right
now
right.
So
is
that
enough
for
now
on
rollbacks
or
do
we
want
other
other
things
that
we
would
need
to
solve
in
order
to,
I
guess:
unlock
more
roll
back
options.
D
A
B
D
A
Yeah,
that
makes
sense.
Okay,
that
makes
sense
cool
okay,
so
that
I
think,
is
good
enough.
Probably
for
what
we
need
for
for
rollbacks
right
is
some
visibility,
so
we
can
make
this
check.
What
do
we
need
to
do
then
for
the
monthly
release,
because
that's
the
other
big
one
right?
Is
this
making
sure
we?
A
B
D
And
just
work
this
through
the
template
when
we
say
something
like
this
is
the
day
you
select
a
branch,
then,
when
you
promote
you
make
sure
that
we
run
positive.
You
kind
of
know
that
when
you
try
to
commit
to
something,
so
this
is
the
thing
that
I
want
to
promote
to
rc42,
so
I
will
not
promote
other
other
packages
for
today
unless
is
needed,
and
they
just
make
sure
that
that
thing
goes
to
production,
that
post
deployment
migration
are
run.
B
Yeah
for
now,
I
think
it
would
be
very
manual
we
will
have
the
tooling,
but
we
will
need
to
rearrange
the
monthly
template
to
mention
this
to
include
the
execution
of
the
possible
job.
A
Yeah,
okay,
I
think
I
could
work.
Certainly
in
the
short
term,
like
I
actually
from
chatting
with
ruben
a
bear.
I
I
think
we're
almost
causing
problems
by
the
fact
we
deploy
so
frequently
that
we
end
up
tagging
something
really
close
to
the
22nd,
because
the
release
post
is
created
on
the
18th
and
quite
often,
we've
done
a
lot
of
deploys
after
that,
and
that's
one
of
the
reasons
why
we've
been
wanting
to
create
this
check
this
the
release
check,
chat
ups
command.
A
A
Yeah
just
so
I'm
thinking
like
what
what
would
it
I
mean
it's
not
going
to
be
ideal
to
have
to
need
to
have
a
day
and
the
month
where
we
we
just
have
to
focus
on
running
these
manually
versus
doing
regular
sort
of
deployments
to
dot
com.
So
is
there
a
like
what
would
be
our
kind
of
way
of
eliminating
that
like?
How
would
it
be
that
we
get
them
in
the
product
and
we
run
them
and
sort
of
change
the
schedule?
A
B
For
them,
based
on
their
content,
that
could
bring
us
closer
to
see
if
they
can
be
a
good
fit
for
the
product,
and
that
would
bring
us
closer
to
probably
remove
them
and
yeah
probably
remove
that
and
probably
replace
them
or
move
them
even
to
regular
migrations
or
to
the
ones
we
can
do
it
or
the
ones.
We
cannot
included
with
the
brother
and
trigger
trigger
them
from
there.
D
Yeah,
I
I
agree
with
myra
just
wanted
to
remark
that
basically
post
diploma
aggression
help
us
to
do
something
a
bit
quicker,
but
you
you
can
split
that
work
over
a
longer
period
of
time
and
have
it
and
it
will
work
as
well
and
for
github.com.
The
longer
period
of
time
is
just
consecutive
deployments
of
a
day,
but
because
we
have
customers
running
on
monthly
releases.
This
means
months
that
that's
the
biggest
problem
here
right,
the
difference
between
ones
yeah.
D
So
with
this
I
mean
this
is
what
we
have
so.
The
problem
that
I
see
right
now
is
that
pos
deployment
migration
is
a
casual
solution
for
several
type
of
problems
and
there's
no
really
they
have.
They
only
have
one
key
aspect,
which
is
they
run
after.
E
D
Now
we
need
to
say
grown
up
as
a
comp
as
an
engineering
department
and
figure
out
why
we
need
to
run
something
after
and
classify
and
fig
and
and
also
find
figure
out.
If
some
of
this
have
other
problems
like
the
thing
we
were
discussing
before,
with
myra
like
the
destructive
migrations
and
things
like
that,
because
again,
destructive
migration
is
a
bad
implementation
of
something,
because
you
can
do
this
over
several
milestones
when
you
just
do
non-destructive
migration
and
then
you
distract
later
on
yeah
right.
B
A
Okay,
that
fits
well
because
what
I
I
I
know
that
makes
it
harder
sort
of
longer
term
to
roll
out,
but
at
the
same
time
I
I
do
think
it
that
we
we
shouldn't
place
the
entire
burden
of
this
change
on
the
release.
Managers
like
this
is
a
great
opportunity,
like
short
term,
for
sure
we
can
do
it
to
unblock
ourselves,
but
you
know
longer
term.
I
think,
having
something
that
changes
the
way
we
we
think
about.
These
things
is
actually
going
to
be.
A
To
get
there,
we
are
going
to
first
do
option
a
well,
no
modified
right.
So
first
step
of
option
e
is
going
to
be
the
splitting
out
the
the
post
deployment
job
and
making
up
manual,
as
is
so
all
the
jobs
in
there
at
the
moment,
release
managers
to
run
that
on
a
manual
schedule
recommended
once
a
day.
B
Yeah
I
try
to
summarize
that
at
the
end
of
the
document
like
we
are
clear,
at
least
I
am
clearing
the
first
two
iterations
and
I
iteration
c
or
iteration.
3
is
the
one
that
is
still
kind
of
turkish.
I
know
that
we
will
have
way
more
data
once
we
have
once
we
have
gone
through
this
iteration
right,
but
there
might
be
a
chance
once
we
have
all
of
this
implemented
that
we
could
decide
like
hey.
A
Yeah
makes
sense
yeah
if
we
got
these
in
the
product
if
it
was
an
admin
type
of
thing,
particularly
for
the
background
migrations.
Would
that
mean
that
we
could
remove
the
person
that
actually
needs
to
or
not
remove
but
change
the
person
that
needs
to
execute
these,
and
it
could
actually
be
the
stage
group
teams
themselves?
Would
it
still
need
to
be
release
managers.
D
I
think
the
biggest
problem
is
access
control.
So
if
I
had
to
do
this
for
just
for
customers
so
not
for
running
github.com
thinking
about
a
customer
installed,
this
on-premise-
I
would
say
it's
an
administrative
task,
so
you
need
to
be
an
admin.
If
I'm
thinking
how
we
operate,
I
would
probably
define
an
extra
rule
which.
D
If
it's
running
migration
like
creating
indexes
or
things
that
are
supposed
to
be
long
taking
a
long
time,
then
I'm
kind
of
expecting
an
admin
of
some
sort.
That
can
run
this
and
we
could
be
that
admin
right.
So
if
we
then
want
to
give
us
admin
access
to
github.com
because
of
customer
data,
fine,
then
we
define
a
kind
of
maintainer
role
that
someone
that
can
run
those
things
without
changing
others.
B
A
Is
there
any
other
stuff
we
need
to
go
through?
Does
this
do
these
notes
at
the
bottom
myra
give
you
enough
for
kind
of
there's
going
to
obviously
be
lots
of
decide
going
on
in
the
future,
but
does
this?
A
C
B
A
That
would
be
my
preference,
okay
just
so
that
we
it's
a
it
and
put
them
on
release
velocity
just
so
that
it's
a
little
bit
less
admin
work
if
they're
not
nested
too
deep.
Okay,
so
we
can
call
them
unless
they
have
to
be
iteration
like
while
you
you
could
literally
call
it.
A
The
epic,
like
you,
know
more
or
less
what
you've
got
your
issue
so,
like
removing
you
know
like
separating
post
deployment,
migrations
off
the
auto
deploy
pipeline
could
be,
it
could
be
an
epic
and
we
could
have
a
second
one
where
we
like
do
the
scheduling.
I
don't.
I
think
the
database
team
might
do
quite
a
lot
of
iteration
too.
C
A
And
then
for
that,
having
that
as
an
ethical
seo
for
the
rollbacks
one,
are
you
happy
that
we
we
use
that
epic
to
just
kind
of
be
the
enabler
for
assisted
rollbacks
and
on
that
on
the
assisted,
rollback,
epic?
We
can
just
literally
like
say
once
we
have
this
other
epic
completed.
D
D
Yeah,
let's
do
this,
I
mean
we.
There
will
be
some
kind
of
something
that
we
can
mark
as
a
blocker
from
the
other
epic,
which
is
kind
of.
E
D
A
I
think
that's
right
yeah,
I
think
so
yeah
and
that's
why
I
think
this
this
first
step
alessio
mentioned
about
like
the
duik
actually
getting
it
so
that
the
check
can
know.
When
did
we
run
this?
Is
it
safe
to
go
back
because
then
yeah?
We
could
just
feed
all
that
into
the
automation
so
yeah.
I
think
that
I
do
think
it
gets
us
closer.
So
that's
that's
a
great,
a
great
aim.
C
B
I'm
gonna
go
again
to
the
document
that
I
send
you
with
the
conclusion
make
sure
that
we
are
also
mentioning
that
doing
these
iterations
could
lead
us
to
in
at
some
point,
remove
the
post-employment
migrations,
I'm
probably
going
to
post
the
comment
on
monday
yeah
and
then
I
will
also
open
up
an
epic
for
iteration
a
and
I'm
going
to
create
issues
for
at
least
the
steps
that
we
have,
that
we
have
recognized
so
far.
C
A
Yeah
we
can
take
it
from
there.
Okay
sounds
good
sounds
good.
It
might
be
worth
have
a
think
about
whether
you
want
to
update
the
issue
description
to
bring
in
option
d
as
you've
got
it
kind
of
outlined
already
and
then
add
option
e,
because
then
we
can
kind
of
we'll
we'll
leave
that
issue
being
the
kind
of
full
picture,
and
then
we
can
just
add
a
thing
afterwards,
where
it's
like.
A
Okay
at
the
moment,
based
on
everything,
we
know
we'll
go
with
this
option
and
you
say
to
everyone
having
to
read
all
the
comments:
okay,
yeah
for
sure,
awesome,
nice
and
in
terms
of
issues,
feel
free
to
feel
free
to
keep
most
of
them
like
pretty
high
level.
For
now,
like,
I
think,
that's
just
the
two
that
we
really
need
to
work
through,
which
is
the
well
three.
A
B
Yeah,
I
think
another
important
one
is
the
visibility
one
like
we
need
to
have
a
tooling
around
the
pending
possible
immigration,
which
is
something
that,
unless
it's
already
working
on,
but
we
just
also
need
to
consider
that
one.
A
A
We'll
certainly
want
to
have
something
going
in
the
release
issue
as
well,
but
it
might
be
worth
bringing
over
some
of
the
extra
pieces
from
our
auto
deploy
pipeline
onto
this
job
as
well.
B
A
Add
those
that's
this
task.
Okay,
fantastic,
give
me
a
shout
if
you
want,
I
don't
mind
if
you
want
to
update
on
the
doc
and
then
we
can,
I
can
have
like
if
you
want
me
to
help
there
or
if
you
want
to
go
ahead
on
the
issue,
go
for
it
there.
That's
fine.
A
Fantastic
all
right,
I
might
do
a
little
bit
of
an
edit
of
this
agenda
and
try
and
get
it
to
match
a
little
bit
more
with
that
conversation
just
a
bit
of
reordering,
but
I
think
we
pretty
much
covered
everything.
One
thing
actually
we
didn't
talk
about
is
the
development
process,
but
I
think
maybe
we
we're
not
going
to
do
it-
we're
not
going
to
make
any
changes
to
that
for
now
right,
so
yeah,
that
is
correct.
It
will
be
the
same
for
them.
It
should
be
transparent
for
developers.
B
A
Yeah
for
sure,
in
fact,
that's
a
great
one.
So
maybe
once
we've
got
to
the
point
where
we
have
a
conclusion
kind
of
meant
like
shared
on
the
issue,
then
we
can
add
that
into
things
like
engineering
we
can
review
and
stuff
and
then,
if
anyone
violently
disagrees,
they've
got
some
time
to
kind
of
shout
right:
yeah,
cool,
okay,
perfect
thanks,
very
much
pringles
together.