For web development agencies
Ship the build you promised. Price the one they asked for.
Plan discovery to handoff with the client’s part in it, and see what a change costs before you agree.

Discovery to handoff, with the client in it.
Each stage has outputs, owners and a dependency or two. The client owns some of them, and the plan says so.
Discovery
Requirements and agreed exclusions go into the project document.
DocsContent
The client supplies copy and images. Development tasks wait on them.
Client taskDesign
Page designs go to the client for feedback through the portal.
Client portalDevelopment
Build tasks point to the technical detail in your engineering tools.
TasksLaunch
QA and debugging are logged like any other work, and the handoff lists what remains.
Handoff document
Price the integration before you promise it.
Illustrative fixed-fee build: a $24,000 contract, 260 hours at an average $60 labor cost and $1,200 of direct expenses. Then the client asks for a stock integration worth 40 more hours.
Compare the request with the accepted scope, estimate the uncertainty, and agree the price and launch effect before anyone starts.
Get the scope change request templateNew request: stock sync with the client's inventory systemEstimated 40 h, outside the accepted scope
- Was it included?Accepted scope and exclusions
- What does it affect?Dependencies and technical estimate
- What changes commercially?Price, scope or launch date
The engagement around the build.
Engineering keeps its own tools. These four parts of Flowboard carry the agency side.
The build
One task the account lead can read.
Owner, status, what it waits on and what waits on it, with the time it took. Progress is explainable without opening the repository.
Stages as sections
Discovery, content, design, development, QA and handoff.
Client inputs as tasks
Access, copy and approvals get an owner and a date.
Blocked by, and blocking
Dependencies show what cannot start yet, and why.
A pointer to the issue
Link the record in your engineering tools and keep the detail there.
Time on purpose
Timers and manual entries. Nothing is inferred from commits.
Internal until shared
Technical tasks stay internal. Client-visible work goes to the portal.
Clear about where the build lives.
What Flowboard runs
- Delivery stages, owners and dependencies, including the client’s part.
- Requirements, exclusions and handoff notes in project documents.
- Time from timers and manual entries, QA and debugging included.
- Fixed-fee margin from the contract, logged labor and expenses.
What Flowboard does not do
- Replace source control, code review, CI or deployment.
- Create time entries from commits or editor activity.
- Offer native Gantt charts or a mobile app.
- Sign off a release. Record the outcome here once your engineering workflow passes it.
Keep sensitive credentials in a secure credential process, outside general project documents. Get the project handoff checklist ↗
The details.
Everything above, in depth. Open what you need.
Plan the whole engagement, including the client's part
Organize the project around meaningful delivery stages such as discovery, content, design, development, QA, and handoff. Tasks should make outputs and ownership clear. Dependencies help identify work that cannot sensibly proceed until something else is ready. A development task can be blocked by missing content just as effectively as by an unresolved technical issue.
Keep the current requirements and agreed exclusions in a project document. Use the client portal for appropriate shared work and feedback, and make approval responsibilities explicit. The client should understand which decision is needed and what delay it may cause. A visible date alone does not explain why the agency cannot finish an integration without access or a confirmed specification.
Keep engineering detail and agency context connected
Developers still need source control, local tooling, build systems, and technical issue detail. Flowboard does not replace those systems. Its useful role is to connect the client-facing delivery plan to the people, time, documents, and commercial assumptions behind the engagement. Use clear references so a project owner can understand the status without duplicating every technical record.
Time tracking uses deliberate timers and manual entries. It is not automatic inference of effort from commits or computer activity. Record technical discovery, debugging, QA, and coordination consistently when those activities belong to the project. A fixed-fee estimate can look healthy if the team records feature development but ignores the work required to make it production-ready.
An illustrative integration request changes the economics
Suppose a fixed-fee build has a $24,000 configured contract amount. The team logs 260 hours at an average $60 labor cost and records $1,200 of non-pass-through direct expenses. Direct costs are $16,800, leaving $7,200 of contribution and a 30% direct margin. These are illustrative assumptions, not a customer result or a project-completion forecast.
A new integration adds 40 hours at the same average cost. If the fee does not change, direct costs rise by $2,400 and contribution falls to $4,800, or a 20% margin. Before assigning the work, compare the request with the accepted scope, estimate technical uncertainty, and agree the effect on price and launch timing.
| Change question | Evidence | Required decision |
|---|---|---|
| Was it included? | Accepted scope and exclusions | Original obligation or new work |
| What does it affect? | Dependencies and technical estimate | Effort and sequence |
| Who can deliver it? | Weekly resource allocations | Staffing and timing |
| What changes commercially? | Fee and direct-cost scenario | Price or scope adjustment |
Set up the first project for an honest handoff
Choose a project where the agency can establish a consistent relationship between the client brief, delivery plan, and technical work. Avoid migrating years of closed issues before the active workflow is clear.
Confirm the scope boundary
Record included pages, functionality, integrations, client inputs, exclusions, and acceptance responsibilities. Identify unresolved assumptions before production starts.
Build a dependency-aware plan
Create tasks and sections around concrete outputs. Make content, access, design approval, and technical prerequisites visible.
Plan people and record effort
Allocate design, development, and QA capacity by week. Track project work consistently, including internal review and debugging.
Review before accepting changes
Inspect remaining work, logged effort, direct costs, and the new requirement. Agree the commercial and scheduling effect before making a promise.
Use the workspace for operations, not as a substitute for release discipline
Keep test results, deployment checks, and release acceptance in your engineering workflow. Record the outcome in the project so account managers can explain progress and the next client action with confidence.
Flowboard connects scope, team capacity, time, client communication, billing, and direct project economics. Use your engineering tools for source control and CI. Native Gantt charts and a mobile app are not currently available.
Control delivery dependencies
Organize tasks and project context around the actual handoffs.
Explore this workflow ↗Record an additional request
Use a structured change document before the new requirement becomes an obligation.
Explore this workflow ↗Questions
Before you plan the first build.
Does Flowboard replace GitHub, GitLab, or our build tools?
No. Keep source control, code review, testing, and deployment tooling where the engineering team needs them. Use Flowboard for the agency engagement around the build, including scope, ownership, client communication, time, capacity, and commercial review.
Is developer time tracked automatically from activity?
Use timers and manual entries to record project work. Team members choose the relevant task, duration, and billable status; commits and editor activity do not automatically become time entries.
How should we handle client content delays?
Make the required input, owner, and dependency visible in the plan. Explain which work can continue and which commitment depends on the missing material. Update the client expectation deliberately instead of leaving the original launch date to imply that the delay has no consequence.
Can we see whether a fixed-fee build is still healthy?
Direct margin connects the configured fee with recorded labor and eligible expenses. Review it alongside the work still to come. Early margin can look strong before QA, integration, or launch effort is logged, so it should not be treated as a guaranteed final outcome.
What belongs in a project handoff?
Include the agreed deliverables, relevant documentation, remaining responsibilities, and a clear account of what has been accepted. Keep sensitive credentials in an appropriate secure process rather than a general project document. Technical completion and commercial acceptance should both be understandable.