Inspiration
Every hackathon track talks about wasting compute, storage, or energy. We picked the resource nobody optimizes because it's awkward to talk about: people. Manpower is the single most expensive line item in any org — and the only resource that suffers when it's wasted. Idle benches, quiet burnout, and "only Maya knows how that works" single points of failure are everywhere, but managers allocate teams on gut feel and a spreadsheet.
What it does
AI-driven dynamic team allocation engine with a draft screen for your workforce. You describe a project in plain English, set a workload, and it drafts the optimal cross-functional squad from skills, availability, and real collaboration history — reads the entire org team comp to expose burnout, idle bench, and single points of failure.
It runs as one closed loop across five pages:
🧩 Allocation Engine (primary) — Type a goal ("Launch a mobile payments app"), drag the workload slider, hit Run. The engine parses the goal into a skill-need vector, matches every employee by cosine similarity, sizes the team to the workload, and greedily drafts the best squad — balancing capability, chemistry, and skill coverage. The drafted members light up on a live collaboration graph and auto-fill department columns with a specific task each.
📊 Dashboard — Live monitoring of the real org: manpower-waste %, idle headcount, burnout flags, and meta balance — surfacing problems like "31% idle and people in burnout."
🕵️ Suspect Board — An Organizational Network Analysis (ONA) graph that auto-flags the Hub, the Silo, and the Single Point of Failure (a true graph articulation point — e.g. "everything routes through Maya at 97%").
⚡ Draft Lab — Detects a losing comp ("5 Core Executors, no Ops") and auto-re-drafts it, showing the before→after impact: idle 31→9, burnout risks defused, balance 54→87 — same people, +18% output.
🌱 Insights — A sustainability scorecard turning all of this into quantified, ESG-tagged recommendations (idle FTE recovered, burnout reduced, SPOFs eliminated).
Crucially, age and gender are deliberately excluded from every scoring path — fairness by design — and every number is fully explainable, never a black box.
How we built it
100% client-side React app — no backend, all logic is pure, testable functions over mock org data.
- Goal → target vector. A free-text goal is tokenized and keyword-matched into a 4-D need vector over [Tech, Management, Design, Operations]:
$$\vec{g} = [,t,; m,; d,; o,]$$
- Skill match via cosine similarity. Each employee carries a skill_vector; their fit is the cosine angle to the goal:
$$\text{capability}(e) = \cos(\theta) = \frac{\vec{s}_e \cdot \vec{g}}{\lVert \vec{s}_e \rVert , \lVert \vec{g} \rVert}$$
- Dynamic team sizing. The team scales to the workload instead of being fixed:
$$\text{size} = \left\lceil \frac{\text{workload}}{2} \right\rceil + 1$$
- Greedy draft. We add members one at a time, each time maximizing a blended score — individual fit, team chemistry (sentiment), marginal skill coverage on dimensions the goal still needs, minus archetype redundancy (so we don't draft five of the same role):
$$\text{score}(c) = 0.5,\text{cap} + 0.3,\widehat{\text{syn}} + 0.2,\text{cov} - 0.18,\text{dup} + \text{bal}$$
where synergy is normalized from a sentiment matrix, $\widehat{\text{syn}} = \tfrac{\text{syn}+1}{2}$, and an optional toggle adds an experience-diversity bonus.
Organizational Network Analysis. We build a collaboration graph from a synergy matrix and compute degree, weighted degree, and run an articulation-point check (remove a node, recount connected components) to auto-flag the Hub, the Silo, and the Single Point of Failure.
Waste & health scoring. A composite metric blends idle %, overload share, and role redundancy into one headline manpower-waste number, with team health from composition balance, skill coverage, synergy, and utilization spread.
The whole loop is wrapped in five pages — Allocation Engine → Dashboard → Suspect Board → Draft Lab → Insights — visualized with a force-directed graph, Recharts, and framer-motion, where the drafted team literally lights up on the org web.
Challenges we ran into
Keyword matching that doesn't lie. Naive includes() matched "ai" inside "available" and "campaign". We switched to whole-token matching so short, high-signal keywords (ai, ml, app) only fire on real words. Greedy without double-counting. A member who's strong on Tech shouldn't keep scoring for Tech the team already has — so we score marginal coverage against what's already drafted, not raw skill. A real SPOF detector, not a heuristic. Approximating "important person = high degree" was tempting but wrong. We implemented an actual articulation-point test over the graph so a true single point of failure is provable, not guessed. Keeping per-run state off shared objects. Allocation scores are computed into a scratch map so re-running the engine never mutates the canonical employee data — every draft starts clean.
Accomplishments that we're proud of
A genuinely dynamic engine, not a lookup table. Team size, composition, and tasks all change live with the goal text and workload slider — the squad is computed, never hard-coded.
A real single-point-of-failure detector. We didn't fake it with "high degree = important." We implemented an actual articulation-point test — remove a node, recount connected components — so a flagged SPOF is mathematically provable, not a heuristic guess.
Bias-resistant by construction. Age and gender never touch the score. We can defend the fairness of every recommendation line by line.
End-to-end explainability. Capability, synergy, coverage, waste, and health each trace to one transparent formula — a manager can actually trust and act on the output.
Shipped fully working, 100% client-side. No backend, mock dataset, pure testable logic — plus a runnable check.mjs with 15 engine/dataset assertions guarding correctness.
What we learned
Fairness has to be architected in, not patched on. The only reliable way to keep bias out was to make sensitive attributes unreachable by the scoring code — not to "correct for them" afterward.
Graph theory maps shockingly well onto org problems. A "single point of failure" is literally an articulation point; a "silo" is a low-degree cluster; a "hub" is high weighted-degree. Org dysfunction has precise mathematical signatures.
Greedy needs marginal thinking. Our first draft kept stacking specialists in the same dimension. Scoring new coverage relative to the team already drafted — not raw skill — was the fix: $$\text{cov}(c) = \frac{1}{\sum \hat{g}} \sum_{i} \hat{g}i \cdot \max!\left(0,; s{c,i} - \text{teamCov}_i\right)$$
Small NLP bugs have big consequences. Substring matching let "ai" fire inside "available"; whole-token matching was essential to keep recommendations trustworthy.
Explainability is a feature, not overhead. The moment scores were traceable, the demo became persuasive — people believe what they can audit.
What's next for DraftBoard AI
Real data integrations. Replace the mock dataset with live connectors — HRIS for skills/availability, and passive signals (calendar density, Slack/Git collaboration graphs) to build the synergy matrix automatically instead of by hand.
Learned skill vectors. Move from keyword parsing to embeddings — derive each person's skill_vector from their actual work artifacts, and turn project goals into vectors via an LLM rather than a keyword table.
Optimization beyond greedy. Add a global optimizer (ILP / simulated annealing) to draft multiple concurrent teams from one shared talent pool without over-allocating anyone. Forecasting & burnout prediction. Use utilization trends to forecast burnout before it happens and recommend pre-emptive re-drafts.
Manager-in-the-loop controls. Let managers pin/exclude people, lock roles, and set constraints (budget, seniority mix), then watch the draft re-solve instantly. Closing the feedback loop. Track real project outcomes against predicted team health to continuously calibrate the scoring weights — so Atlas gets sharper with every draft it makes.
Built With
- autoprefixer-data-viz:-recharts-(charts)
- css-framework-/-build:-react-18
- graph-articulation-point-(spof)-detection-tooling:-eslint
- html
- languages:-javascript-(es-modules)
- node.js
- organizational-network-analysis-(ona)
- postcss
- react-force-graph-2d-(collaboration-/-ona-graph)-animation:-framer-motion-icons:-lucide-react-algorithms-/-concepts:-cosine-similarity
- vite-8-styling:-tailwind-css-v3
Log in or sign up for Devpost to join the conversation.