Last, maybe our last one for the year last live stream. We're gonna do a part two of how we have been framing up this project for this internal dashboard. So I'm gonna leave it on here. We may bring some team members on me bring the show there.
And last week we just opened up, you can go watch the first part. If you're interested in this, but we just started with a totally blank canvas.
We mentioned that we had a team retreat here in Franklin and we did a whole kind of mock up of ideas of different things that would help our team be a little bit more efficient.
So it happened by just putting the ideas doing some brainstorming. Everybody kind of wrote down stickies and then we just each person presented their ideas.
Then we captured all those ideas and we kind of organized them in some stickies here just to kind of see
it doesn't mean that every single sticky now has to go into a backlog or any of that. It just was like, hey, generally, there's this sense that we need this one view. So one of the
things that arose was this idea to have a new view that gives team members and clients and admin clarity on billing and schedule. So
I think this is very much a similar view with like different filters on it, potentially. And so last week we kind of framed up
some context here. I won't going to read all of this, since you can go back and watch how we got to this point in the other video.
And we've kind of talked through the problem here and then kind of what we want the outcome. So I'll just kind of focus on the outcome here is we want to
be able to move budget around and have just visibility on what's expected on basically for schedule and billing for clients. We have this view, which took a little screenshot down here for quick reference.
Where we will take a client and then we will have, you know, each column has kind of like
you know the month and then what projects are happening in the month and then what weeks each size project is and what's the status, what's the payment status. There's a lot of information here and Notion doesn't really
give us a nice way to display this is pretty limited as far as how this works and it can still be a little bit overwhelming to clients.
Because we're still talking in weeks where maybe they want to see dollar amounts or
you know, maybe they want to see, you know, we kind of total up here that there's five weeks for that month. So anyway, this is just the kind of the limitations here. And one of the big things that we sort of framed up in a part two here and I may take
this and we're just going to just like you would in, you know, Git, in a Git repository, we're going to fork this and I'm just going to draw a little line and this will be our
official, this will be December 23 session. So we're just going to kind of keep the, we're not going to delete that, we're going to keep it open there.
But one of the big problems that we identified more than anything as we got into a second session was this idea of
there's really, since we're using Notion, so one of the top things here that's relevant. This is a bunch of, I'm just going to put the most important stuff at the top, but most important thing is we
we heavily like rely on Notion for all like projects and tasks.
And I'll say task management.
And so because of that, one of the problems that arises, like we have very limited
control over what users can see, let's say like what projects, you know, and what what access they have, essentially, what
we'll say maybe capabilities, I don't know, okay.
They have to modify. So like if we share, one of the problems right now is we have one massive database called projects and they're all organized with filters by client.
And so in order to share a list of projects with a client, we actually have to share the entire projects database with a client.
So technically, they have access to every single project. If we wanted them in Notion to see this kind of really, you know,
So technically, they have access to every single project. If we wanted them in Notion to see this kind of recreation of this view down here, they'd have to have every single
and they could basically go to any single project of any kind. And they can, we can put them in a read only mode, but then they can only read
their own stuff. They can't interact and stuff. So it's not, it's not ideal. So what we thought would be sort of the, this idea is this view idea was really the most important thing here
is that we just wanted a way for them to view the same data. Same thing that's in Notion, just view it in a different way, but it gives us control over knowing that this is a client or this is a team member that's looking at it. This may be an admin that's looking at it.
And we can hide and show different things on the screen. So that, that created a lot of clarity, how we got there. And this is, we did a session between last Tuesday and this session. So this is actually technically our third session.
And I'll just show you guys this. We actually just started, we started doing a breadboard, but then we went to the next session.
We sort of zoomed out a little bit and we said, okay, how does this work?
We had this idea of like clients doing a multi-month retainer.
So they agree like, Hey, we want to do three weeks per month at this rate.
So they'll have an idea.
They'll give it to us.
We'll frame and shape it.
They confirm that we're using the weeks.
And then we, on the first of the month, they purchased those weeks.
We do work, review, kind of go back and forth as they give feedback.
And then once we finish it, we like release funds to the, to the team for that.
So that's kind of our little, that's sort of how it is to now.
And we even thought of like how we could clean this up a little bit.
So we sort of zoomed out quite a bit because we also didn't want to start
building software for something that is actually a process problem.
So this also happens as well because we are also, I'm the client in this case
and our team, it really is the client.
In this case, we're doing it for ourselves.
We have the control of also fixing the process.
And so this can be a little bit of a painful problem when you, when you're
working with other clients is they need to be open to also sometimes, sometimes
the process itself is not good and you can't really fix a bad process with software.
So if you have a pretty good process and you just want to remove some of the
friction, that's a good time to like bring software into the mix.
And so what we did here is we just, just made sure that our process was simple enough.
And so we did come up with kind of a nicer idea where clients would have an idea.
They could frame and shape, we'll frame and shape it.
We'll propose it to them.
And this could, doesn't have to happen on the, like it happened
anytime during the month.
They can confirm it.
We do the work, we review it.
And we thought of having some like master approve button where we actually mark
the work as completed, at least in Notion.
And then we'd kind of release and that whole project would be done.
So we just, this isn't really super relevant to this, but it does help us give
context of actually just looking at it.
Cause until we got into this, we had never even put these blocks on a board at all.
And these are just something that was in my head.
Maybe it was in Lucian's head, maybe it was in Macy's, but it wasn't clear.
And so by me having to draw it and everybody seeing it, you know, it kind of
helped us move the things around and said, okay, we kind of have it working this way.
We probably should simplify it a little bit to do it this way.
And then we actually got into some of the breadboarding stuff here where we said,
well, we started looking at even like, how does the shaping take place?
Like we meet with the client, we book the shaping calls.
We do actually like a, this is sort of the initial, like, Hey, we want a
project that does this and this.
Then we get into a 90 minute shaping session where we look at, you know, kind
of all these different pieces that we're sort of doing with you guys now frame it.
We give an appetite.
We typically do a second shaping session, if it's internal or with the client.
And then we actually asked them to approve it.
And then we sort of book it and off we go with that.
So that's sort of the process, how a new project comes in the door.
And so this is important because this is what's happening sort of at this phase.
And we needed a screen where all this could take place.
So this is sort of what's happening on the process side.
And maybe we'll just add some definitions here since I wasn't very clear.
So then we, we said, maybe we would have, let's see here.
Future, this is some of the future.
So we, then we started mapping out, did I do a client one?
Yeah, I think this was the, this actually should say client, I think.
Sorry.
So we, we said you would have some sort of navigation.
You would look at the dashboard.
We could kind of see like a chart of like weeks and stuff.
And then we would have these totals and some, something to show
like the different weeks.
So one of the, so we kind of got this far into it.
We even try to like map out just, this would be sort of like our fat marker sketch.
It's not a UI.
It's not even really a wireframe.
It was just trying to like, I had an idea down here.
And so I scribbled it out really quick with some of the texts just
to kind of illustrate what it is.
It's kind of another version of what we, what we had here.
And we also looked at like just these little diagrams here to show like, Hey,
what was actually happening?
Like we had clients paying in the first, sometimes projects ran
into December and then we'd have to like approve and wrap it up in December,
but they actually paid for it in November.
So this is just very complicated.
And so we wanted to figure out how we could simplify it.
So anyway, these are just some of our scribbles and I just put this
line, we can reference it if we need to.
There's nothing in here that's going to be like officially published
anywhere in our SOPs or anything like that.
It's just us getting our, like what's in our brain down on paper.
So we could talk about it.
And then one thing we like to do, just to get in a process is we like
to think of the Hill chart here.
And we have some sort of like magic moment here where we want to get to clarity.
And what's happening down in here is we have things like we're doing.
The framing stuff, we're doing this breadboarding,
which we haven't really even got into the breadboarding
specifically.
We also do some quick prototyping is happening here.
And all of this is happening before we've
kind of hit this middle part.
So that's why we spent, now this will be our third hour
going through this.
So from a time standpoint, we're probably
like 20%, 30% of our hours for this project
have been used up so far.
And that's OK.
We're happy to spend up to half of the hours
just on this first half.
Because once we get this really crispy point of where
it's super concrete, and we know exactly what we got to go do,
then we just map out the steps.
And we just go execute.
And we use AI, of course, down this side
to do a lot of we'll call it agentic coding.
And we test it, and we get the clients.
But typically what happens is people
jump too soon into the coding.
And so it's not crispy yet.
It's not ironed out.
Lucian and Macy were very patient.
Because as soon as this is one of the first projects
we're doing, so we're trying to get a lot of clarity
on a lot of things.
So it really forced us to whittle down
what we're not doing in this project.
And so let me come over here.
So one of the things I did was a prototype.
So we actually went over to our dashboard.
We have our website.
And what's cool about our little Next.js website,
we have a way to actually sign in.
So we don't have a separate app.
It's just one single app that's our website.
And then you can flip over to a dashboard.
And so then there's a client role,
there's a team member role, and there's a admin role.
And so right now, I've just broken them up
by team, client, and admin here.
And so if I go to the client dashboard,
I went ahead and just prototyped this out.
And when I say prototype quickly,
this took me an hour, maybe two hours.
It was not a lot of time.
And I only did this maybe after we had gotten
some of the clarity here.
So I did a quick prototype, knowing
that we may throw this away.
And the one thing I wanted to figure out
was I didn't really get this idea of the control piece.
Because what we wanted to do is we
wanted clients to be able to come in here
and pick up a card and drop it, let's say,
into a different phase, where they mark something
as completed.
We wanted for them to quickly see a much prettier UI,
like they could see the budget from this standpoint.
They can see that they're on schedule.
So on schedule, on budget, little green, green.
And we can see the total weeks here.
And we can see that we have five weeks in progress.
And maybe they can switch it from like a status view
to like a month view if they wanted.
And so that's possible too.
And so this is kind of like where we got to.
And the other thing we typically do a lot
is we have this inbox status, where just a ton of stuff,
like there's 12 weeks worth of things in here.
And we don't like to show it, because it normally
clutters it up.
And then, of course, we have this completed,
which is everything we've ever completed for this client.
So there's just a lot in here too.
So what we thought would be nice,
and I kind of stole some inspiration,
we'll say, from the Fizzy app.
So they have this column that kind of opens and closes.
So a really cool UI.
And we just borrowed that concept for this.
And same thing on completed.
We can pop it open, check stuff, and pull it closed again.
And so that way, things are a little bit more clear.
And of course, we could click into this
and maybe go to a detail page.
We already have some pages in here
that show you details about the project.
And from here, we can, of course, go into Notion
and jump deep into this project of how we're actually
tracking it and stuff.
So again, this is just a quick prototype of this.
And what we did was I just got it started,
and then I showed Luchin and how it works in our team.
And if you're working on our team, this is how it will go.
But we have a single Notion project
with all the information.
And you can link to things like the breadboard,
and you can link to the task grid.
And then we've got things like comments here.
So all that happened was we met last Tuesday.
We, I think it was maybe Tuesday or Wednesday,
Macy and Luchin and I had a few clarity bullet points here.
And then the next day, I just went in and by myself,
I just built a little prototype.
And it doesn't even look that pretty when I made the video
and made a quick preview.
And then Luchin and I went back and forth.
And we started to get some clarity.
So I just wanted to show you that there's
a lot of asynchronous conversation happening here.
And this is something I think.
Lucien and I have been working together for the longest of anyone on the team.
And it's, we're kind of starting to get to the point where we can have good,
uh, uh, like transfer of knowledge and thought back and forth without having
to be on a, like talking face to face.
I love hanging out face to face or in person, but this is great because I could
put my thoughts and when he had a moment, he would be able to re watch the video,
look through the, the, where I was and then give his thoughts that, you know,
um, he was having, so this is good.
So we, this is sort of the, the real, just wanted to show you guys what it's
like, how we work, um, you know, on a real project, because we've did a bit
of coding to get it to this point, but I also just prototyped it in a way that I
could delete this whole module, um, because we haven't really nailed anything down.
I just wanted to see how hard is it to actually, um, build this and get it, get
kind of a UI together to where, and it was, it was me building the UI that I
realized, oh, I get to have full control over what the client's seeing.
And that's actually what we've been missing.
Um, was this sort of.
Controlled view where they don't have to be invited to notion.
They don't have to be invited to a bunch of weird database, like task
databases and project databases.
And that's invited to our whole client database.
Um, I could just make this one view that's reading the API.
And, um, we were able to do a simple little test year where if I drag it
and drop this into shaping, um, and I open this up here in, in notion, you
can see it's just shifted to shaping.
If I come back, of course, um, here and I move it back to in progress and it
immediately like jumps to in progress and notion, so little prototype and a
little proof of concept to show that like, it actually could feel very much
in sync with what our team's seeing and notion, but it's like a much cleaner
view of it and that's where we got a lot of clarity.
So that was a very long update.
I don't know, Lucian, if you want to share some thoughts on this or so, or
where we got to so far, and then we'll dive into some specifics of what to decide next.
Yeah, you pretty much covered the main points.
I would just add that like framing.
It's like, you can never be like too clear on the framing.
So like even we did the prototype and we came back like, ah, this clarifies the
framing and that was probably where the, the biggest like gold happened.
Yeah, I agree.
Um, and we may come back here and it's not so much maybe about the budget anymore.
I would, I would actually say it's, we can put that in a not doing, but, um, we
just really want like, um, a single like view for, for clients, um, to see all
like, um, projects, um, their status, maybe they're like, um, their schedule
and, um, total appetite or something, something like that, just like a high
level overview for the client and something that honestly, like this could
be pretty enough where I could screenshot this and drop it in Slack.
You know, like I could just screenshot this, drop it in Slack.
They can glance at it and be like, okay, so we went over here.
These are on schedule though.
Great.
All, all good.
Um, and we may have like a few in review.
And one of the things we really want to, uh, that we identified here.
When we breadboarded it was when we go into review, we need the clients to
really be involved with getting things out of review and into the completed
status because things can sit, um, as you guys all know on the team, I think
sit and review for a while.
And sometimes, um, we had stuff that wasn't even, um, closed.
And, uh, another thing that we, um, we ran into, I think it was over here.
And if I, uh, went into notion, we actually just built this one board,
which we hadn't been using for a while, but this was every project organized
by status, um, across all clients.
And so we actually quickly found stuff that was in review.
That was maybe like six months old when we did this.
And, um, and, uh, it was, it was kind of, it just, you took the, and we didn't
even, we didn't even build anything.
We didn't write any code.
Once we got the clarity of like, oh, there's this view that's kind of missing.
We're like, oh, we can actually make that view in, in notion in five minutes.
And so we were able to quickly create that and kind of got pretty similar there.
You can see the status of the hours.
You can see the, um, billing.
It doesn't quite show you the date if we're on schedule or not, but, um,
it's a good, good part of that.
I don't know, Greg, if you were wanting to add something popped on.
Okay.
You're good.
Um, I wanted to add something about like, you know, you said that, uh, you
know, software doesn't fix like a bad process, like going through this.
We also got the clarity of like the end review.
It's like, it was a bit fuzzy.
Like what is in review?
Is it like kind of code review by a peer or, and we've, we figured it's better
that like, we are all like done and like shipped and like the client is looking at
it, that's what's in review, like until like you're done and you're giving it in
the hands of the client to say like, is this good enough?
Like, are we done with this?
then it's still in progress up to that point.
Yeah, definitely.
And I think one, so I think what we were missing, and it's, it's so simple, like
once you draw it out and we kind of like, Oh yeah, these, these, these different
spots, there's kind of two things where like people have to take action has to
take place where we need the clients to actually come in here and approve it.
And that's actually a pretty big blocker for, for Macy and me when we're, when
we're making sure, like, was this actually approved because there's, sometimes
they, we get a verbal, yes.
Sometimes it's a reply in an email.
Sometimes we get an emoji on a Slack thread.
Like it's pretty it's not very concrete for the clients to do that.
So we came up with this process, which again, is maybe part of more like we
would call like the monster project, which is maybe a few projects strung
together, but we talked, this came out in the team discussion and I'm not going
to specific you know, stickies here.
I just remember it was, it was so, it came up so many times with the team
that it's just top of mind.
Right.
So I didn't have to really think about it.
It just came up a lot when we were talking about it, but maybe having
something where we send something to a client and it says, Hey, like there's
a, yes, I approve this or like, no, I want other changes and they hit yes.
And it's kind of like their signature on the project to say, we've now approved
this and then everything else, just the work can begin and we can kick it off.
And then the same thing happens at the other end, kind of like these two
bookends of the project, because it was a little bit vague, it wasn't super clear.
And since we deal in the currency of like clarity and crispiness on all our projects,
like we should definitely have a process that's just super clear for clients and
the team to know exactly, you know, when things are ready to be worked on and so
forth.
So this, so that was good.
Cause yeah, we didn't have a good, and this all came because we had this column
called interview that wasn't, we didn't know what it was for.
But when we said, Oh, the clients need to move it out of, they're the only ones that
can move it out of interview to complete it.
We, I think we, I don't know if we said that somewhere, but I remember there was
this like clarity moment where like, Oh, we're not allowed to move it out of
interview.
Like, unless we're on a call with a client and they say yes, then we'll move
it together.
And then we'll still leave a comment and be like such and such client approved
this.
That's how we should get things out of interview.
And then it also creates like a nice hard stop and we don't have this tail because a
lot of times things can sit in review and then two weeks later a bug pops up and we
kind of reopen the whole thing and it's sort of never ending.
So anyway, that, that was just yeah, how we got some clarity there.
But I think, I think this is getting more simple.
I don't know if we want to just quickly clean this up.
If you have any thoughts, Lucian or Ira, anyone want to jump in as well?
Yeah, maybe it's in the details a bit, but I got really nice, like clarity here
about the process, you know, where I was saying about like in review should be
just when the client is looking at, um, there's like a process thing that it's
like not clear when it's done.
What we can do is like have a, you know, just like notion automation that you have
to like create, um, what do we call, um, we saw this like Ryan video, he's doing
like case study and like they, they have a deliverable thing, like a document that
like shows like, Oh, this is how you use the new feature.
And like, just like kind of the summary of like what was built or like a video
demo or something like that, like a deliverable and you have to like have
that to create like an in review to, to change status in review.
So that could be like a good, you know, process and it would be like pretty
simple to just like, um, do some software that enforces this, you know?
Yeah, that's great.
Um, so one thing I'll leave here is like the views are, we'd like to create
are technically impossible in notion.
I think it's one that you said there, it's kind of similar to this one.
I could probably clear these up.
Um, so I, and I think this one's very much, and I'm what I'm shaped.
So in, in, uh, the shape up, they have a great little diagram, which I don't
have time to like find, but we have this like random blob of a project.
And so we've kind of started to carve out like sections of what the, I mean, they
call these kind of the vertical slices.
So one of these, one of these things is the actual client view here.
Um, and the other one may be like a team member view.
The other one may be like security.
So what we were going to focus on is we can actually get this all solved for the
client and publish it and start using it as a company and then go back and like
solve a different problem, which is like, how did the team members see this?
So how did the admin see this?
Because we can, you know, this could turn into like a, you know, one, a two week
project versus being maybe a six week project.
Um, so because I'm always like, I'm very much in the mode of like, get something
small, that's really, really useful, ship it and let us start.
using it. And then we'll go and figure out the next thing. So I would say anything that's
not related to the client piece, I would almost take those things out initially,
just because then at least we're all looking at this client view and the clients can see
what's going on. Because I guarantee it, we look at a board like this every single day,
maybe pull it up with clients, but they're not looking at this and they're not looking at it
the same way. This means a lot to us, probably doesn't mean a lot to clients because they're
just not using it every single day. And so it looks kind of unfamiliar and it looks confusing.
So we want to just simplify that. So what's nice about having the blocks like here,
while you guys were talking, I just dragged a couple of these things that they're not doing.
So it's very clear, not only am I deleting it, but I'm specifically saying nothing to do with
clients. So is there anything else we want to tweak on this?
Anyone on the problem or outcome? And then we'll move on.
Not doing project changes, like the last item in the outcome.
Oh, this one?
Yeah.
Yeah, we can take this out.
I mean, this project could just be like client view,
and then we have like a shipped, an actual thing, and then we can look at the next thing.
Yeah. And part of this is like, this is like more on the process side.
And projects will require admins to, so, and this may be good because maybe this like
approval process is actually part of it is because we don't,
because we said this is where they can see stuff, but I think maybe there's also like a,
now that we kind of sliced it differently, we sliced it to like team to the clients only.
We could say like, a like tool or just like a, we'll say a way for clients to
approve projects before work. And I don't know if it's approved. What did we said?
We came up with a really good word for it. Approve. And then like.
Approve and fund.
Yeah. Something like that.
Even if you say fund, now it's like, does that mean we have to have like this hooked into Stripe?
Does it mean like, it just opens up like approve projects before work?
And kind of a move to completed after interview. This is not written well, but maybe it's
a little wordy, but I'd rather be. So maybe there's a way for them to approve it in this
phase. Cause we, this could be a button. So so many times these, like this whole outcome,
I think I drew it somewhere over here. It could literally just be a button that says like,
they hit approve pops up. It says like, are you sure you hit? Yes. And then it's like approved.
Um, cause we couldn't really, there's not like a great mechanism to do this in notion. Yes. You
could make like a check box that says client approved. Yes or no. And they could check it,
but like then anyone else can uncheck it. So it's just kind of, it's not a very like
definite thing where we could have a button when they push this, it like updates the status to
dev ready. It makes a comment in the notion project that says such and such user approved
on this date for this thing at two weeks. And we has a kind of that log in the comments on the
notion. So that could just be a button. So I don't think, I think that's very much in scope.
Um, it's probably two hours of work to add that. Um, and that could be kind of get us this outcome
we're looking for. Um, and then maybe it's the same thing once the project is, so we really have
like a kind of, we're confusing it even I'm in confused because we have these two points of like,
Oh, maybe it's confirmed and approved. Maybe those are the two.
Yeah. You just have to watch out like, cause it opens the edge case that they
approve, but they didn't pay. And then the dev gets like the, the dev ready status.
Sure. So, so that's good. Cause you brought that up and then I immediately want to like
swap that away. Um, so let's just like, that's good. Cause, cause there seems like there's
something vague there. So we'll say like, um, uh, no, um, like we'll say like, uh, payment, uh,
processing included project. Um, we'll just be like, uh, admins will keep close watch. We don't
have a hundred projects happening in a week. Cause we're tracking. It's like, uh, you track
like payments away from view. It could be like, if it's linked to a payment and it was approved,
then it's okay. So just like, I think it's fine if they approved it here and they hit the button
Like, it felt a little more formal.
We don't even do that now.
And then we have to deal with the movement of money
afterwards.
That's probably fine.
If they hit yes and they approved it,
and we basically have a log where they're like, no,
you requested this work on this date,
we're never going to get into issue
where we could even do the work, even if they haven't paid.
We still have the log of them formally approving
the work to be done.
But yes, I think down the road, it'd be super cool
if it just pulls a Stripe transaction.
It's one little movement, 100%.
But just for the sake of getting this one launched,
because it runs into other problems
where not all clients pay us through Stripe, for example.
And maybe it needs to generate a Mercury wire
request versus Stripe.
So yes, maybe that's another project.
But I'll just say, don't worry about the processing right now.
Yeah, current, future projects.
Knowing which projects are paid for, that's fine.
And then I don't even have to worry about this.
Yeah, I think this is fine.
This probably feels small enough now.
And then I think the appetite's pretty simple.
I would probably put two weeks on this, which for us
would be 50 hours, roughly, in normal language.
I think that's definitely doable.
It's probably a one-week project, honestly.
But part of the outcome of this is us also
doing it together as a team.
So we probably are doubling up the time
just talking about it with all of us on the call.
We're probably way over our budget with nine of us
on this call.
OK, anything else you guys want to add?
And then I think we're good.
We'll take 10 minutes and kind of breadboard a few things.
But anything else you guys want to add here?
For you guys, Ira, Janata, Lucian,
you guys are typically in with clients.
Like, this is what I'm seeing from my standpoint, which
may be a little bit different than yours.
Are these problems that you think the clients have
or that you have at times, does this
add any benefit for you to see a view like this?
I mean, we're in Notion, so it's not probably very useful.
But we also didn't want to assume that everybody
was using a view like, I think we actually came up
with like a My Dashboard team dashboard.
Yeah, we did create this little sample dashboard
so you could click on what all the team was doing,
my projects, what's in review, and so forth.
Because the one thing I love about Notion
is it's highly customizable.
And I also hate that about Notion
because I can have one view that looks amazing for Bruce.
And Lucian could have his own view that
looks amazing for Lucian.
And then like, Ira and Janata don't use that or see it
because you have to sit there and make it yourself.
Like, you have to build your own view of this stuff.
So I don't know if this is helpful.
Yeah, I think I'm using something similar.
But I think the most important part of having this,
I think we really nailed down the part of what really matters
is to have this view accessible for the customer.
Because Notion is like really good to use and stuff
and it's very flexible.
But incredibly, like the sharing system, it's strange.
And if you send to a customer, they have to like be logged in
and not everyone uses Notion.
So it creates a lot of friction with the customer.
So for instance, like with Hackstack,
they are a customer that we are running for a long time
and they don't use Notion a lot.
So I think if you have something that we can use as a basis
to like have the customers to look to help customers
to create the habit of like using this
as the main point of reference, I
think this is the key value, especially
for this long term running project, where
you can like have plan like one, two, or three months ahead.
But we need to like to have this common view where everyone
can look and see, hey, this is where we are going.
We agreed that we are going to this direction
and we agreed at this point in time.
So I think my main.
The main use for me for this specific view is to improve client communication.
Like it's to have a point, a source of truth where we can always point customers
back to, and we don't have to rely on them, like using Notion or like having to
know how to use Notion because we can like, make it as easy or as complicated
as you want, because we are like creating from scratch.
So I think it's, it can easily, like sometimes if you think like it could
like sound like an overkill, but if you use Notion and if you shared stuff
with it, you'll know that that's not an overkill, like especially if the
other end is not accustomed with Notion that like doesn't have the practices
and doesn't use it a lot, it can create a lot of friction.
And like, for instance, every month we need to share the new database with,
or like we need to, to review the share, the access to chase if they're
seeing the reactive stuff or not.
I mean, like this kind of creates unnecessary friction and breaks like
the, the possibility of creating a habit around it.
So yeah, I think, sorry, really long handling around it, but, but I think
it's, it's I think it's my, my way of seeing it's like having the source of
truth and easy access for the customer.
Okay.
That's good.
So I'll just, I think we're in a good spot.
So I would, I started doing this last time.
Let me just grab this.
So we're going to kind of have like maybe two components.
I think this by status is helpful because they can quickly see like
everything moving to the right.
But maybe from a billing standpoint, we do need it rearranged to the month
view, which is kind of more like this, where it's got columns for each month.
It might even be better to have like timeline view.
Cause it's not always like a clean overlap.
Hmm.
Yeah.
So maybe it's, I'll just say, yeah, let's just, yeah.
Roots.
Um, maybe by, by I'm going to give it a, a, a ugly name, like work dates or by,
uh, maybe it's a project calendar or something.
It could be a cam Kanban or I don't really care what, what it is.
We'll figure that out.
And I want to piggyback off of what Janata said.
You asked about like, what, like pain points.
And cause now we have like, you know, the monster projects and like
kind of showing them the sequence of upcoming work and like reshuffling.
That is like, this project has like huge potential to, to help
the communications on that side.
Sure.
So I just want to, so this, I think is clear, the Kanban stuff
like makes sense for me here.
Um, since we, so we already didn't have like a immediate clarity on
the, on, is it Kanban or is it timeline?
I'm just going to put projects by dates and then we'll figure this out later.
Um, and, uh, we could have like, um, uh, for the month would be helpful.
We also want to see like the, um, and then what I would say is, uh,
actually have like a component here called the, um, project card.
And this would have like the title and you guys, we got like a total,
or we'll say actual hours versus, um, total hours or something like that.
We could also have even, I might contest this because on the client side, they
don't even necessarily need to know.
It's more like an internal metric.
Like, were we clear enough on this project?
If we weren't, then we end up spending more time than we should have.
And on their side, they just know that they paid this much and like the dates
that we like wanted to complete it by, you know, it's not even necessarily
relevant to them, like how many hours we spent on it.
I think, yes, but also, um, it does cause this, this actually told, this
is actually the total appetite.
Cause it does show movement.
Um, it's just that we don't like stop billing clearly on the, uh, like this
guy, like 38 hours out of, so I love showing this to clients, um, because I
paid for 30 or like we, like they only paid for a week, but they got like 150%
more, like 50% more than what they want.
That's on us to fix, not, not on them.
Um, and there was a bunch of like research and stuff happening on this.
We know why that was there.
Cause there's another bigger project coming, but this is nice because it
does kind of show you, um, progress.
Like if this is it just cause we want to make full transparency.
So I think this is just a, like a, um.
like a way to add clarity to the,
like, or just shows them that work's being done
because it's hard to know because they're not,
most of the clients are not technical.
They just know like, oh, ours have been invested,
which is maybe pretty, yeah, I don't know.
And this at the risk of throwing like a monkey wrench
into this, which I love doing, but you know,
potential process like question or, you know, blurriness is,
because on this like project that's gone,
we're over scalability upgrade.
A bunch of that time was spent shaping the next project.
And that's kind of like, like when we shape a project,
should we be billing on that project,
which hasn't been paid yet.
So there's a bit of like, you know, circular.
Yeah, yeah, yeah.
That's true.
I think those are more like definitely process things.
And once we have the clarity for it as well,
I think there was also in our process,
there's probably like a little post project debrief for,
even if it's just a few comments back and forth,
but just to look at these numbers.
And if we get this project card that feels very clear
that anyone can look at this and kind of see what happened,
it's like, oh, there's something to talk about that.
Like, okay, it went over,
did we just forget to change the dates?
Do we massively underestimate this?
This is a very unique project and I'm not worried about it,
but it'd be good to like just talk that through
to see, you know, did it actually need,
and there's maybe other projects which are probably,
actually, where is the, did we just finish the,
where's the attachments one?
Yeah, it's weird.
Maybe it's a bug in your prototype
or is it, I'm pretty sure it's in review.
It's in review?
Is it in review?
It doesn't have the right client, maybe?
I'm checking it out.
Okay.
I'll wait just a second.
It has two clients.
Just delete this one.
Yeah, and it's in review, so it should be showing up.
That's it, so yeah.
Maybe it's in the tribe one then.
Yeah, go ahead, Ira.
Yeah, so I think it's,
since this is for the, our clients,
I think it's important to see like the,
if we're going beyond like the agreed upon timeframe,
but in terms of the progress bar,
I feel like it would be better to have the progress
maybe in terms of, so one thing I always use,
I use the monster map or like the verticals.
Right.
Like, yeah, these are the points,
and maybe that time bar is like,
there's a chunk for each of these verticals.
And so they can like click it and see, okay,
well, you're working on,
you've completed these two verticals and like that.
I think that my concern with like letting it be based
on time is I try to, when I can,
I try to like implement it as quickly as I can, you know?
And I don't wanna be in a situation where,
because I'm trying to like do clever things
and like get it done faster that it's like,
oh, well you can actually work faster.
So for your next project, we'll.
Yeah, yeah.
You know?
Yeah.
I think it's, yeah.
Either way.
And then also they always see a full,
they'll also, they'll always see like a full 100%
like thing, which as I'm like tackling the verticals,
that bar will always hit 100%,
where if it's based on time,
it could potentially not 100%.
Okay.
Yeah.
You guys happy?
Yeah.
So conditional, if that's there,
if not, we just wanna see,
we still wanna see the app.
Like we still need them to see that this is,
what's the appetite maybe somewhere?
Cause this would tell you that it's two weeks.
And so that, and it's really the first couple hours.
So we can do that for now.
We can have that little conditional.
I'm okay with that for now.
Cause, and this is exactly what we can't do in Notion.
So this is one like line of code
wrapping that one little component.
It's a great, great example where we could actually
super quick to change that.
And maybe they do wanna see it down the road.
And we enable it or not.
Sorry, I said end team.
This is where admin here.
We just have two different roles right now.
And I think that's Chinada's dog.
My dog under my desk is gonna start barking at him.
That's good.
So we can kind of breadboard this out.
We're going to kind of wrap this up in like two minutes
because I got to jump to the next thing.
But this is just a great example.
It kind of felt pretty cool when you guys all looked at this
and were like, this is awesome.
Let's ship it.
We could probably send this to a client today.
And then we get into this discussion about this bar.
And all of a sudden, we're not clear anymore about this bar.
So that's good.
And I think what we'd do is probably have the same project
card if we can.
I don't know why we would need a different component.
But what's nice about this is we start
to see that there's one project card component.
And then we can maybe arrange them in two different views,
whatever those views might be.
Maybe it's a timeline.
Maybe it's a calendar.
I suspect it's going to be a little bit of both
because I think the timeline view is pretty nice.
We actually looked at this.
Do you remember who you built it for, Lucien?
Was it Kavimars?
Oh, yeah, timeline.
So we started to do this kind of view.
Again, this is a great example where
you have to use a bunch of filters
to get this to not look insane.
And I think it looks better if you look at quarter
because it kind of zooms out a hair.
Exactly.
And there's limitations.
You can't filter by start date or end date or stuff like that.
Yes, it's just all projects right now,
and then including completed.
So this list is pretty long.
And if you hide completed, it's hard to see.
You kind of want completed but only
completed within the last 90 days or something.
You don't want it from two years ago.
But anyway, something like this potentially
could be good because you can kind of see this timeline.
So we'll play with that.
I'm not going to worry too much about it.
What I did start to do as well, we call it the task grid.
This is a tool Ryan built, which we really like,
which is just this grid of nine things.
And so I'm going to go ahead and delete this.
Can you delete stuff?
Oh, you can't.
I'll let him know about that.
So we're actually not going to do any of these things
for this project.
And I said by month here.
There's some security stuff right now.
We have to make sure that this client, if they signed in,
we know which client they're supposed to be associated with.
I can do that.
And then I've got this view by status.
And maybe I'll make this as the project part.
The approve button, so they have to log in.
We can't not let them log in.
So there's two.
There's confirm process.
And so I wouldn't go typically in our heads to this.
But this is better to know that just to make that clarity,
there's a thing here.
We need to put some tasks into this bucket.
What's not in here is, yeah, if you're a client,
then we would have something like if in the whatever it's
like shaping status and client logged in,
then we would show some sort of confirm project button.
So and then this will just go to a whole flow basically
of like confirm project.
I don't know what's in here.
But there's something in here.
And I assume there's a big confirm button, right?
This can be very quick and smooth.
And then that's it.
There's nothing really after that.
It just kind of loops you back to the view.
I think it includes a notion comment.
Yes.
And that would be illustrated here
with like a little gray thing.
I've got to use these words correctly.
Confirmed project on like y date.
There's my cue.
Cool.
So we'll have something like this happens.
I don't know.
We probably have some other things
we want to do in the database.
And it updates the status, obviously.
We'll like update notion status, et cetera.
So you guys get the idea.
But just breaking this into a little piece,
we can kind of see what's going to happen in the database.
So now I could very, very quickly add
like this needs to send comment to notion.
This needs to change status in notion and a few other things.
So I can keep going on this.
But you guys get the idea.
I'll keep wrapping it up later today.
And then following our process, I will make a quick video
and share like.
the final breadboard here.
And you guys can follow.
Anyone on the team here can follow the project here.
It's called New.
And I'll keep posting, and you guys
can see the whole history of the conversations here.
So I'll put a new video later today, some links there.
But you guys can all comment and weigh in on it
if you have thoughts.
But I think it's definitely getting really, really clear
of what we're building.
And once that's done, we'll obviously
go and add maybe the team member stuff next.
But cool.
Awesome, guys.
That's awesome.
Closing thoughts?
You're like 50% shaped, right?
Yeah.
We always do.
No, this is good.
Because we always, at the end of it, just be like,
where are we at?
And it's always like, oh, this is awesome.
We're at 90%.
And if you really think about it,
you're like, we're probably like 60.
Lucian says 50.
I'd say 60.
Because we're just used to like, this
feels so much more clear than maybe other projects we've done.
But every time we get something really, really clear,
and we're like, oh, this is the 80-90, now we're like,
OK, that's actually what 80-90%, 100% feels like,
there's just this like, we've kind of ruled out
all the edge cases.
We've answered all the questions.
Now Ryan says you get to this point where you're like, OK,
could you just stop talking about it?
Just let me go build it.
I'm ready to go build it.
Let me start coding.
I know exactly what to go do.
And then you kind of know you've hit it.
We're close.
I think we're close to that.
So awesome, guys.
Well, I hope everybody has a good Christmas.
And I think we'll probably skip next week.
But we'll catch up with you guys soon.