Why Every Category Goes From Experimentation To Consolidation

Introduction

In August, a provost, a CIO, and a registrar sit in a windowless room with a spreadsheet. The sheet lists 122 tools students will touch in the first four weeks of the term. The registrar circles five: two tutoring pilots, a scheduling app, a note-sharing tool, and a proctoring service added by a single department chair. The CIO highlights the same row for a different reason: all five take a nightly CSV from the SIS and send grades back through ad hoc scripts. The provost asks the operational question: “If this breaks the week before midterms, who is on the hook?” No one answers, because ownership is distributed across grants, departments, and vendor success managers. This is not a governance parable; it is the operational floor on which categories are formed.

Every edtech market I have worked in or around has moved through the same practical sequence: experimentation, fragmentation, standards, consolidation, professionalization. I saw this pattern firsthand with the early learning management systems. An academic project to help faculty post syllabi online grew, merged with Blackboard in 1998, and by 2004 Blackboard (NASDAQ: BBBB) went public. Between those points lived the full lifecycle: pilots on a crossover cable in a lab, then a crowd of course tools, early standards work at IMS Global, and—once institutions demanded reliability at scale—consolidation and professional teams.

A useful way to picture the process is a rail line being laid across rough ground: first local spur lines built quickly to reach a mine or a mill, then dozens of gauges and switches, then a hard choice on a standard gauge, then the trunk lines that get funded, and finally dispatchers and timetables. The metaphor is not the point; the operations are.

The claim here is simple: categories don’t mature on a hype curve; they mature on an operational curve. Procurement writes history. When you understand the operational curve, you can time your product and buying moves so that each step is additive rather than a rework.

What experimentation looks like

On the ground, experimentation starts with a constraint that shows up as a specific job to be done. A department needs to move a lab experience online for six weeks while a building is renovated. A state grant appears that must be spent by June 30. A device shift—like the iPad in 2010 or Chromebooks in K‑12—changes what teachers can do in classrooms. Or a pandemic forces emergency remote instruction. The response is concrete: a pilot is scoped to fix one problem for one population on one timeline.

Funding and ownership in pilots

Money for pilots tends to be close to the edge of the organization: departmental funds, discretionary dean’s budgets, foundation dollars with narrow aims. The buyer is close to the end user and time-constrained. That proximity produces a healthy bias to action and a risk: the pilot’s success metrics are local and short-term. If the tutoring tool helps at-risk students in one math sequence this fall, it is a win—even if it sets up a support or integration problem later.

Technical choices that enable speed

Experimentation favors tools with low setup cost, flexible authentication, and forgiving data flows. Single sign-on is nice but often optional. Vendors accommodate with manual CSV imports, light-weight SIS connectors, or human-in-the-loop support. The right thing to ship is what can be stood up by a department IT lead or a tech-savvy faculty member in a week. Everyone involved knows it is a bridge, not the bridge.

How vendors behave at this stage

On the vendor side, the signals are equally operational. Sales cycles are short, pilots are free or discounted, product teams accept edge cases, and reliability is measured in hours of weekly uptime, not months without incident. Logging and reporting are functional but not forensics-grade. The roadmap is fluid and largely driven by the last ten customer calls. In this phase, great vendors learn where the real pain sits; the weak ones mistake pilot velocity for product-market fit.

Speed is rented; integration is owned.

From experiments to fragmentation

If a dozen pilots work, success creates its own challenge. By spring, the spreadsheet in the CIO’s office has doubled. Two math departments picked different proctoring tools. Three advising pilots are running on separate campuses within the same system. A growing set of students now use five or six tools before midterms. The word “stack” starts appearing in meetings without a shared definition of what is in the stack.

The cost of variance

Fragmentation’s cost is often misdiagnosed as a licensing issue. The first-order cost is operational variance: too many practices to support, too many ways to move the same data, and no common places to look when something fails. The tutoring tool imports rosters on Sunday night; the scheduling tool pulls them hourly; the proctoring service wants a fresh feed before each exam. Support staff spend mornings checking dashboards instead of helping instructors teach.

Human middleware and brittle data flows

In this phase you see a lot of “human middleware.” A coordinator downloads a CSV from the SIS at 6 a.m., cleans a column, and uploads it to three tools. A developer writes a script that turns grade exports into something the LMS will accept, and the script lives in one person’s home directory. Errors look like missing students in the middle of the week or stale course sections that never close. The human layer is heroic, but the system is brittle.

Security, privacy, and accessibility gates appear

As more tools touch student data, the review gates get real. What sailed through a department in two weeks now goes to an information security officer, a privacy review for data retention, and an accessibility review against WCAG. These are not obstacles; they are the way you scale trust. But the combination means fewer tools make it through each cycle.

Fragmentation is not failure; it is the bill for speed.

How standards emerge and harden

Categories do not consolidate because leaders grow tired of supporting many tools; they consolidate because shared interfaces reduce variance and enable a cleaner handoff from pilot to production. In edtech, that handoff has been advanced by multi-decade standards work—much of it under IMS Global, which rebranded to 1EdTech in 2022—and by the operational codification inside institutions and vendors.

Data and integration standards that matter

A short, non-exhaustive list of the edtech standards that have moved the needle:

• Learning Tools Interoperability (LTI): a way for external learning tools to launch from an LMS with context, handle grade passback, and manage roster data. Early LTI versions were about launches; later versions hardened security and deeper services.
• OneRoster: a way to move roster data between SIS systems and tools. It aims at the brittleness of CSVs and the one-off scripts that plague the fragmentation phase.
• Common Cartridge and Thin Common Cartridge: packaging course content and links so they can be moved across platforms.
• SCORM: older but still present in legacy and corporate learning stacks; it defined packaging and runtime behaviors for content long before cloud platforms normalized web APIs.

Standards are not just technical. Contract clauses about data retention, privacy promises, and uptime SLAs become normalized; security questionnaires become checklists rather than novel essays; accessibility expectations shift from “we intend to comply” to “show your VPAT and remediation plan.”

Why standards take time

Standards mature the way software does: early drafts reflect what is easy and what a few influential players can ship; field use reveals edge cases; security incidents drive revisions. A standard that has endured five production cycles across five different vendor stacks is a different thing than a PDF spec on a website. Institutions learn to read the difference.

The standards pivot and the gauge choice

This is the pivot point in the rail metaphor. Early in the railroad era, regions used different track gauges, which made through traffic costly. When a common gauge won, trunk lines became bankable. In edtech, when LTI moves from checkbox to default behavior—or when OneRoster replaces brittle CSV imports—the category can support larger, longer-lived contracts because the integration risk is lower and measurable. Procurement starts bundling requirements with confidence that multiple vendors can meet them.

Standards reduce variance; reduced variance funds scale.

Consolidation’s operational logic

Consolidation often gets narrated as a strategy story—M&A, market share, platform plays. Underneath, it is an operations story: reliability, total cost of ownership, and predictable outcomes win budget authority. When CIOs and provosts see the same use cases recur and the same integration patterns hold, they codify them and fund them at the center. That codification is what allows the next leap in scale.

Procurement bundles needs

Once standards harden, RFPs shift from feature checklists to outcome and interoperability requirements. Instead of ten pilots for tutoring, an institution runs a single competitive procurement with clear LTI and OneRoster expectations, defined data-retention clauses, and explicit support and training packages. The vendor that can demonstrate stability over multiple terms and clean integrations will beat a feature-rich newcomer nine times out of ten.

Suites form and acquisitions follow

Consolidation does not always mean one winner; it often means suites. A vendor with a strong LMS acquires an assessment tool that already speaks LTI and can be governed with the same SLAs. A K‑12 platform buys a roster sync product to reduce onboarding friction across its catalog. In higher education, you saw this in the mid-2000s as LMS players aggregated capabilities. In 2006, Blackboard acquired WebCT, reducing variance across two large installed bases. In 2009, ANGEL Learning was acquired and folded into a larger footprint. In K‑12, PowerSchool has assembled a broad suite around the SIS to meet district-level procurement patterns.

Why incumbents sometimes miss

Not every consolidation move wins. Incumbents can misunderstand where the standard sits and try to create a proprietary alternative to defend margin. That move works for a while, then loses as buyers enforce the standard in RFPs. Startups, meanwhile, can overestimate the speed of consolidation and slow their roadmaps to chase integration checkboxes too early. The institutions’ clocks and the vendors’ clocks rarely match; the work is to stay close enough to the operational reality of the buyer that your timing is right.

Consolidation is the reward for predictable operations.

Professionalization takes root

When a category consolidates, the next thing that appears is not a triumphant press release—it is a team. Titles change from “instructional technologist” to “director of digital learning operations.” Job descriptions add explicit change management responsibilities, incident response expectations, and vendor management disciplines. What was a best-effort support channel becomes a ticket queue with response-time objectives and a post-incident review.

Governance moves from meetings to playbooks

In the professionalization phase, governance stops being a calendar invite and becomes documents people actually use. Standards are expressed as configuration baselines and security controls. A quarterly review with vendors covers SLA adherence, bug burn-downs, and upcoming dependency changes (for example, when an LMS will roll forward to a new LTI version). Accessibility is tested, not sworn to. Data governance answers become audit artifacts.

Metrics shift from adoption to outcomes

Upstream, success lived in pilot-readout decks: number of instructors trying the tool, self-reported satisfaction, snapshots of engagement. Downstream, metrics mature: enrollment-to-completion rates for courses using the tool, comparative measures of assessment reliability, support ticket volumes per active user, change-failure rates during term time. Finance pays attention because costs align with measurable outcomes.

The career path appears

Professionalization creates a career ladder and a community of practice. Regional user groups mature into working groups that publish operating runbooks and reference architectures. Vendors stand up customer advisory boards with technical depth. Training and certification move from “nice to have” to a requirement for access to admin consoles in production.

Professionalization is reliability at human scale.

A case study: the LMS category

The learning management system is the clearest case of this lifecycle in edtech—because we lived it in public over a quarter century. An early web-based system was built to meet a direct need: put course materials, assignments, and discussions online with the tools available then—Perl scripts, early web servers, and faculty energy. After a 1998 merger formed the initial Blackboard, the category accelerated. By 2004, Blackboard went public as BBBB on NASDAQ, signaling investor confidence that the operational curve could support durable revenue.

Experimentation and early fragmentation

The earliest years were pure experimentation. Departments and campuses tried multiple systems—some open source, some homegrown, some commercial—and each had a slightly different model for courses, roles, and content. Authentication was often local; roster sync was manual; content packages were idiosyncratic. Faculty were the heroes, copying content forward each term and troubleshooting with students directly.

Standards and the developer ecosystem

As adoption widened, we saw the need for shared interfaces. Through the early 2000s, IMS Global’s work on content formats and tool interoperability created a backbone for the next phase. Within Blackboard, we built the Building Blocks developer program to invite third parties to extend the platform with supported APIs. The aim wasn’t buzz; it was to reduce variance by moving extensions out of one-off patches and into predictable containers. When multiple LMSs could launch external tools with a common handshake and pass grades back reliably, institutions started writing those expectations into RFPs. That, in turn, let them run larger competitions with less risk.

Consolidation and professionalization

Once campuses could rely on cleaner integrations, the category consolidated. In 2006, Blackboard acquired WebCT, rationalizing two parallel stacks and reducing operational variance for institutions that had to pick a lane. In 2009, ANGEL Learning was acquired. Around the same period, open-source options matured: Moodle grew a global footprint; later, Instructure emerged with a cloud-first Canvas that added credible choice and reinforced the standard-driven handshake model. Professional teams inside institutions grew to manage LMS operations with change windows, incident plans, and semester-bound freezes. The market did not converge to one vendor; it converged to a smaller set of vendors that spoke the same standards and could sustain enterprise-grade operations.

Lessons that generalize

The LMS story is not unique; it is just visible. The pattern shows up in assessment, tutoring, advising, proctoring, K‑12 communication platforms, and more. When you can name the standard (LTI, OneRoster), the suite (SIS + LMS + assessment), and the owner (director of digital learning operations), you are in or past consolidation. When you cannot, you are upstream, and your operating model should reflect that.

Developer ecosystems harden when standards pay the bills.

The forces that reset the cycle

Cycles repeat not because people forget but because the substrate changes. A device wave, a network wave, a policy wave, or a workforce wave can reopen space for experimentation and restart the arc in adjacent categories.

Device and network shifts

The iPad in 2010 and widespread K‑12 Chromebook deployments changed the classroom surface, which reopened experiments in assessment, note-taking, and content creation. Mobile broadband and better Wi‑Fi shifted what could be done off-campus and on buses. New device capabilities—cameras, sensors—created room for skills assessment products that didn’t exist before.

Cloud and multi-tenant architectures

Cloud hosting turned capital budgets into operating budgets and changed release cadences. Multi-tenant architectures let vendors push frequent, small updates—great for pilots, risky for term time unless you had a strong change-management discipline. Vendors new to the space often had to relearn that semester calendars and exam windows are not negotiable.

Policy and funding changes

Privacy laws hardened review gates. Federal and state funding programs created targeted demand that favored experimentation (because the money was near the edge) before rolling into consolidation (as recurring funds and accountability appeared). District and system-level strategies about data interoperability started to carry teeth.

Shocks that stress test

In 2020, emergency remote instruction put unplanned load on every tool in the stack. The winners were not always the tools with the most features; they were the tools with predictable operations, clear runbooks, and honest communication—because operations beat features under stress. That event reset adoption in several subcategories and accelerated the move from pilots to standards one or two years ahead of plan.

AI and the next arc

The arrival of large language models into mainstream faculty and student workflows has reopened early-stage experimentation in assessment design, feedback, and content generation. Expect the same arc: a year of pilots to figure out what is practical, a year or two of fragmentation and policy-setting, and then standards and suites—likely anchored in existing platforms that already own identity, context, and data rails.

Platform shifts don’t erase the cycle; they redraw the map.

Operating guide for founders

Founders operating in edtech can increase their odds by aligning product, go-to-market, and operations with the stage the category is in. You cannot skip steps, but you can set yourself up to hand the baton cleanly to the next phase.

Stage-aware product strategy

• Early experimentation: ship thin, solve one job end-to-end, and instrument the parts of the workflow that will later need to integrate (identity, rostering, grade passback, content). Avoid speculative integrations you cannot maintain.
• Fragmentation: pick the two integrations that matter most in your segment and get them right. Publish what you support and what you do not. Do not let custom work swallow your roadmap.
• Standards: invest in the specific versions your buyers run, and design tests that mimic their semester rhythms. Being correct in July and brittle in October is worse than being late and solid.
• Consolidation: strengthen reliability tooling, observability, and runbooks. Prepare to sell total cost of ownership and to respond to RFPs with measurable claims.

Operational posture and evidence

• Status pages, incident histories, and honest postmortems build trust faster than adjectives. Share uptime by term, not by quarter. Show change windows.
• Security, privacy, and accessibility documentation are table stakes. Treat them as product, not as paperwork. Keep them current and tied to releases.
• Publish a standards roadmap with dates, versions, and constraints. Buyers know that LTI 1.3 and migration timelines are not toggles.

Pricing and packaging

• In early phases, align your price with discretionary budgets near the edge. Reduced scope and shorter terms beat discounts for unscoped commitments.
• As the category hardens, price for outcomes and operating savings. If your integration reduces human middleware by ten hours a week, tie that to your commercial offer.

The handoff from pilot to platform is the make-or-break.

Operating guide for buyers

Institutions can reduce noise and move faster by naming the phase they are in and setting expectations accordingly.

Run better pilots

• Write an exit criterion before you start—what specific result earns a scale-up, a re-scope, or a stop.
• Fund integration work up front for any pilot you think might scale. The hardest work is identity, roster sync, and grade/record return.
• Limit pilots to the term cadence. Avoid mid-term changes unless risk warrants. Protect instructors and students from churn.

Prepare for standards and consolidation

• Maintain a living catalog of approved tools with versions, integration methods, data flows, and owners. Shining light on variance is step one.
• Track standards and versions explicitly (LTI, OneRoster, Common Cartridge) and keep a migration calendar that vendors can see.
• When you write RFPs, make outcomes and interoperability specific. Require logs and evidence, not statements of intent.

Professionalize the practice

• Name the operational owner for each category and give them cross-functional authority. Support, academic leadership, and security must be in the same conversation.
• Establish change windows tied to academic calendars and hold them. Publish impact calendars for instructors.
• Create a post-incident review process that favors learning over blame and includes vendors when appropriate.

Clear ownership beats bigger committees.

Why every category consolidates

At maturity, a category is no longer a list of products; it is an operating capability. Institutions pay for reliability, predictability, and measurable outcomes. Vendors that can deliver those with evidence, at scale, win the right to expand. The rest is narrative.

The steps in short sequence:

• Experimentation: find signal with minimal friction.
• Fragmentation: pay the price of variance; learn what matters.
• Standards: reduce variance; create a bankable interface.
• Consolidation: bundle needs; fund the reliable.
• Professionalization: make the capability repeatable by people, not heroes.

If there is a unifying principle, it is that people do not fear change; they fear loss—lost time, lost data, lost trust. Each phase that reduces those losses adds the confidence needed to fund the next scale step.

Procurement, not hype, marks the mature phase.

The bet I’d make today

If I were building or buying in 2026, I would align to the next obvious standards lane and invest where the operational risk is most tractable.

• For founders working around AI-assisted teaching and assessment, assume that identity, context, and grade return will live inside the LMS or the SIS and that LTI (and its successors) will be the handshake. Build the intelligent layer, not a parallel roster.
• For K‑12 communication and parent engagement, expect OneRoster to be non-negotiable and privacy to be the first hard gate. Design your onboarding around district data calendars and give districts a live view of your data flows.
• For tutoring and advising, build evidence pipelines now. If you can measure enrollment-to-completion effects credibly and show how your integrations protect instruction time, you can survive consolidation waves.

The metaphor that opened this piece closes it: once a common gauge is chosen, capital funds trunk lines, dispatchers set timetables, and the network moves people and goods with far less friction. In edtech, once standards settle and governance professionalizes, categories do the same. Everyone gains operating headroom: students and instructors get fewer surprises; administrators get fewer war rooms; vendors get longer contracts for doing the unglamorous work well.

What to do on Monday:

• Name the phase your category is in and write down the two signals that prove it.
• If you build, publish your standards roadmap and your last two postmortems.
• If you buy, publish the owner for each category and the change window for the next term.

That is how categories move from experimentation to consolidation without leaving people behind.

Every edtech category looks chaotic up close—and then, suddenly, predictable in hindsight. There’s a reason for that.

New tools don’t land into clean white space. They hit constraints: budgets, policy, device shifts, staffing. Leaders run pilots to solve a concrete problem this semester, not to “innovate” in the abstract. That is the right move. But once a dozen good pilots exist, the system starts to creak: stacked logins, CSV exports, unreachable support, unclear ownership. That’s not failure; that’s the mid-game.

Across 25+ years building and investing in edtech, I’ve watched the same arc repeat:
• Experimentation → Fragmentation → Standards → Consolidation → Professionalization.

Signals to watch:
• Experimentation: fast cycles, flexible funding, no hard integration gates. The goal is proof, not permanence.
• Fragmentation: tools multiply and support cost climbs. Human middleware glues brittle data flows.
• Standards: APIs and data models stabilize (IMS/1EdTech LTI, OneRoster; legacy SCORM). Security and privacy become real gates.
• Consolidation: suites form and procurement bundles needs. M&A accelerates. Reliability and unit economics win.
• Professionalization: roles, playbooks, SLAs, and governance replace heroics.

The point isn’t to skip steps. It’s to time your move.
• Founders: design for the handoff from pilots to standards. Ship two critical integrations, publish reliability data, and price for total cost of ownership.
• Buyers: write clear exit criteria for pilots, and fund integration early. Evaluate alignment with your standards and your SIS.

Case in point: the LMS category. CourseInfo launched in 1997 and merged into Blackboard in 1998. Standards matured via IMS. The space consolidated (WebCT in 2006; ANGEL in 2009) as institutions demanded reliability and scale. Professional teams followed.

If you can name the standard, the suite, and the operational owner, you’re at consolidation or beyond. If you can’t, you’re still upstream. That is actionable.

I wrote a full post mapping the lifecycle and the operational signals. Share it with your team and use it to align procurement, product bets, and governance.

#EdTech #CategoryLifecycle #Standards #Consolidation #ProductStrategy