Hemant Gupta — Content Assembly Deep Dive
Content Assembly Feature Deep Dive / Nov 2022 – Jan 2023

Bulk Document
Generation

Scaling template-driven document production from one-at-a-time to enterprise-grade automation, and establishing UX patterns that made generation accessible to non-technical users.

Scaling Beyond One-Off Generation

Content Assembly proved dynamic document generation worked. But the UX was fundamentally one-at-a-time. Enterprise customers needed hundreds of documents per operation—contracts, offers, letters. The original experience made that impossible. And the blockers weren't technical.

💡 The Real Problem
Orchestration, not generation. Users needed a way to upload data, map it, trigger batch processing, and retrieve results. The mental model was fragmented: where do I start? What's the flow? Which columns matter? Non-technical users couldn't figure it out, and Power users had to invent workarounds.
UX Friction Points
  • Affordance gap Bulk generation wasn't discoverable in any obvious place within SharePoint. Users had no mental model of where to even start.
  • Mental model mismatch Templates had variables (Recipient Name, Company Name). Lists had columns (First Name, Last Name, Organization). Bridging those two was the user's job, and it was confusing.
  • Setup friction Multi-step workflows that felt cumbersome for power users and impossible for anyone else. Without clear guidance, users got stuck.
Three-Month Execution: Plan → Design → Validate

The work spanned Nov 2022 through Jan 2023 with three distinct phases, each building toward a single design decision:

  • Nov: Direction-setting Co-led scoping discussions with PM. Reframed the question: "Where in SharePoint should users trigger bulk workflows?" Answer: "Where they already have their data—in Lists."
  • Dec: Spec lock Co-authored the feature spec, establishing MVP scope (template selection + column mapping only), UX principles (simplicity > feature completeness), and non-negotiables (error recovery, data validation).
  • Jan: Design validation Ran end-to-end user scenario workshop. Resolved the ribbon-vs-menu affordance debate using data. Agreed on teaching bubble approach for onboarding.
The key leadership moment wasn't designing a beautiful UI. It was saying no to feature requests, pushing for list integration, and running a workshop that moved the team from debate to consensus. That's design leadership.
Entry Point: "Integrate" in the List Ribbon

The complete design file shows three key states of the list integration. The primary affordance is a ribbon button labeled "Integrate" that sits alongside native List commands (View, Edit, Delete, Share). This placement signals that bulk document generation is a first-class capability, not an afterthought.

📐 Complete Design: List Integration with CA View Design System →
Three-state design showing list page with Integrate button, ribbon commands, and teaching bubble onboarding
Design rationale: Frame 1 (baseline) shows the Integrate button in context. Frame 2 adds a teaching bubble (Day 0 experience) to guide first-time users. Frame 3 demonstrates the pattern at scale with sample data rows. This three-state progression builds confidence before users click.
Design Principles Applied
  • Affordance clarity Ribbon placement over context menu or inline actions. Users don't hunt for the feature—it's immediately visible alongside other list-level commands.
  • Guided discovery Teaching bubble (not a modal) appears on first visit. Users can dismiss it, and it won't reappear. This balances education with allowing power users to move fast.
  • Mental model cohesion The "Integrate" button invokes Content Assembly workflows from within the user's existing data context (a List). No context switching to separate UIs.
  • Progressive disclosure First click shows template selection; second step handles column mapping; final step reviews and triggers generation. No intimidating multi-step form up front.
  • Error resilience Incomplete mappings are flagged before generation starts. Users get clear, actionable guidance: "Column 'Recipient Email' required for template 'Offer Letter'."
Pattern: Minimal, Discoverable, Reusable

I used this feature to solve a roadmap-level scaling problem: move document generation from one-off usage to high-volume workflows by grounding the experience in SharePoint Lists and making the entry point extensible.

  • Roadmap alignment I aligned design and product scope around scale, not just feature completeness. The MVP intentionally prioritized list-integrated orchestration, clean mapping, and error recovery over adding every advanced control in V1.
  • Entry-point extensibility I pushed for a ribbon-level list entry point so new workflows could be surfaced without redesigning the full experience each time. This made bulk generation a reusable interaction pattern instead of a one-off UI.
  • Flow-of-work signal I also learned that many enterprise users relied on Power Automate and API-driven flows for high-volume generation. SharePoint UI alone was not always in their daily flow of work, especially for teams centered in Word.
Platform learning
This feature clarified a key scale principle for me: when confidence in system accuracy is high, enterprise customers often prefer UX-light, API-driven automation for volume workflows. Product experience still matters, but it must coexist with orchestration channels like Power Automate.
Evidence-Based Design Leadership
  • Co-driver Dec 2022 spec design review—framed design intent, validated UX principles, and signed off on information architecture with PM and engineering teams.
  • Scope contributor Nov 2022 planning—shaped what "bulk generation MVP" meant, including what to defer (complex data transforms, API-first flows) and what to prioritize (list integration, simple mappings).
  • Workshop organizer Jan 2023 discoverability workshop—led end-to-end scenario walkthrough, surfaced architectural tensions (ribbon vs pane vs inline), and documented decision rationale.
  • Execution signal Tracked through design reviews and feedback loops; ensured that implementations matched UX intent and that customer feedback loops informed post-launch iterations.
Design Leadership Scope
  • Spec co-author Enabling Bulk Document Generation using Content Assembly Templates (Dec 2022) — Shaped MVP scope, UX principles, and error recovery strategy. Rejected feature requests for complex data transforms; locked MVP at template selection + simple column mapping.
  • Direction setter Nov 2022 planning — Advocated for list integration over standalone UI. Reframed the question from "where's the best place to build a new experience?" to "what existing context can we leverage?" This shift set the trajectory for all downstream feature work.
  • Validation researcher Jan 2023 workshop — Facilitated end-to-end user scenarios with PMs and engineers. Surfaced the ribbon-vs-pane tension that the team had been debating. Used that workshop output to create a decision matrix and drove consensus.
  • Pattern librarian Post-launch (Feb–Jun 2023) — Documented the list-integration pattern as a reusable template for future features. Created Figma component set and design guidelines that became the foundation for Agreements and SPAI Verticals.
From MVP Pattern to Platform Standard

I did not treat Bulk Document Generation as a single feature release. I treated it as a scale pattern: use SharePoint Lists for extensible entry points, support orchestration through automation, and keep authoring aligned to where users already work.

  • MVP in Content Assembly (2022–2023) I established the list-integrated bulk generation pattern to solve immediate scale pressure while keeping the model understandable for non-technical users.
  • Pivot to Word authoring (2023 onward) As we observed limited SharePoint footfall for day-to-day authoring, I helped drive the direction toward Word-native authoring flows while retaining batch generation support through automation channels.
  • API + Power Automate continuity I helped preserve the extensibility story by ensuring high-volume workflows could remain UX-light through APIs and Power Automate, instead of forcing every operation through an interactive UI layer.
This taught me how a 0→1 product actually scales: first make the workflow trustworthy, then make it extensible. When customers trust output accuracy, they naturally move toward API and automation-first execution for high-volume operations, with UI used only where it adds real decision value.