For years, one of the most common critiques of the BLoC pattern has been boilerplate.

Between declaring event classes, state hierarchies, constructor parameters, private fields, super-initializers, and event handler registries, you could easily write 50 lines of code before handling a single real-world user action.

With Dart 3.13, that all changes.

Dart 3.13 brings Primary Constructors, this constructor body blocks, and new/factory constructor shorthands. When combined with BlocSignal—the synchronous, signals-powered evolution of BLoC—the result is an ultra-concise, fully type-safe, and boilerplate-free state management workflow.

Let's explore how Dart 3.13 and BlocSignal fit together like hand in glove.

1. Zero-Boilerplate Events & States

In classic BLoC, defining a family of immutable events or states meant writing repeated constructor signatures and field definitions for every subtype.

🔴 Before Dart 3.13:

sealed class UserEvent {}

class UserFetchRequested extends UserEvent {
  final String userId;
  UserFetchRequested(this.userId);
}

class UserUpdated extends UserEvent {
  final String name;
  final int age;
  UserUpdated({required this.name, required this.age});
}

class UserLoggedOut extends UserEvent {}

🟢 With Dart 3.13 Primary Constructors:

sealed class UserEvent {}

class UserFetchRequested(final String userId) extends UserEvent;
class UserUpdated({required final String name, required final int age}) extends UserEvent;
class UserLoggedOut() extends UserEvent;

A whole sealed hierarchy of events or states can now be declared in just a few clean, expressive lines without losing type safety or exhaustiveness checking in switch expressions.

2. Streamlined Dependency Injection in CubitSignal

In CubitSignal, you typically inject repositories, API clients, or analytic trackers. In previous Dart versions, you had to declare each field, accept constructor arguments, and forward initial state to super.

With primary constructors, field declarations and super invocations live right in the class header.

🔴 Before Dart 3.13:

class UserCubit extends CubitSignal<UserState> {
  final UserRepository _repository;
  final AnalyticsService _analytics;

  UserCubit({
    required UserRepository repository,
    required AnalyticsService analytics,
    UserState initial = const UserInitial(),
  })  : _repository = repository,
        _analytics = analytics,
        super(initialState: initial);

  Future<void> loadUser(String id) async {
    emit(const UserLoading());
    try {
      final user = await _repository.fetchUser(id);
      _analytics.track('user_loaded', {'id': id});
      emit(UserSuccess(user));
    } catch (e, st) {
      onError(e, st);
      emit(UserError(e.toString()));
    }
  }
}

🟢 With Dart 3.13:

class UserCubit(
  final UserRepository repository,
  final AnalyticsService analytics, {
  final UserState initial = const UserInitial(),
}) extends CubitSignal<UserState>(initialState: initial) {

  Future<void> loadUser(String id) async {
    emit(const UserLoading());
    try {
      final user = await repository.fetchUser(id);
      analytics.track('user_loaded', {'id': id});
      emit(UserSuccess(user));
    } catch (e, st) {
      onError(e, st);
      emit(UserError(e.toString()));
    }
  }
}

No field re-declarations. No duplicate parameter names. The dependencies are immediately available across all methods.

3. Event Handler Registration via the this Block in BlocSignal

One of the most powerful features in Dart 3.13 is the this constructor body syntax. When using primary constructors, constructor body logic (such as registering event handlers with on<E>() or asserting preconditions) is placed inside a this { ... } block in the class body.

class SearchBloc(
  final SearchRepository repository, {
  final SearchState initial = const SearchInitial(),
}) extends BlocSignal<SearchEvent, SearchState>(initialState: initial) {

  // Dart 3.13 primary constructor body
  this {
    on<SearchQueryChanged>(
      (event, emit) async {
        if (event.query.trim().isEmpty) return emit(const SearchEmpty());

        emit(const SearchLoading());
        final results = await repository.search(event.query);
        emit(SearchSuccess(results));
      },
      transformer: restartable(), // Zero-stream event concurrency!
    );
  }
}

The header cleanly declares the class contract, and the this block sets up the event pipeline.

4. Immediate Reactive Wiring with createEffect

BlocSignal includes createEffect, which automatically tracks signal dependencies and manages teardown on container disposal. With primary constructor parameters in scope, derived cubits can synchronously wire up upstream state containers in the this block:

class CartSummaryCubit(final CartBloc cartBloc)
    extends CubitSignal<CartSummary>(initialState: const CartSummary.zero()) {

  this {
    // Automatically reacts to cartBloc.state signals synchronously:
    createEffect(() {
      final items = cartBloc.state.value.items;
      final total = items.fold<double>(0, (sum, item) => sum + item.price);
      emit(CartSummary(count: items.length, total: total));
    });
  }
}

5. Named Constructor Shorthands (new) for Testing & Seeding

Dart 3.13 also introduces constructor shorthands, allowing you to define secondary named constructors using new name() without repeating the class name:

class CounterCubit(var int count) extends CubitSignal<int>(initialState: count) {
  // Named constructor shorthands:
  new zero() : this(0);
  new seeded(int initial) : this(initial);

  void increment() => emit(state + 1);
  void decrement() => emit(state - 1);
}

This makes testing variations, mock seeds, and default configurations concise and readable.

🛠️ Enabling Dart 3.13 in Your Project

To take advantage of these features:

1. Set the SDK Constraint in pubspec.yaml:

environment:
  sdk: ^3.13.0

dependencies:
  bloc_signals: ^1.0.0
  bloc_signals_flutter: ^1.0.0

2. Enable Dart 3.13 Linter Rules in analysis_options.yaml:

include: package:very_good_analysis/analysis_options.yaml

linter:
  rules:
    - use_primary_constructors
    - use_declaring_parameters
    - unnecessary_type_name_in_constructor
    - unnecessary_primary_constructor_body

🚀 The Architectural Payoff

By combining Dart 3.13 language features with BlocSignal, you get:

1. 0ms Synchronous Updates: State emissions propagate in the current frame without microtask delay.
2. Minimal Ceremony: Class headers declare fields and super initializers simultaneously.
3. Signal Graph Efficiency: Automatic == de-duplication and fine-grained UI rebuilding.
4. Standard BLoC Rigor: Clean event dispatching, state transitions, and OpenTelemetry observability.

💬 Over to You: What's Your Take?

We'd love to hear your thoughts in the comments below:

1. How do you feel about Dart 3.13's primary constructors? Does declaring fields directly in the class header match how you design your domain and state layers?
2. Are you planning to adopt primary constructors across your state management classes, or are there specific patterns where you still prefer classic constructors?
3. Have a boilerplate-heavy state class or Bloc? Drop a snippet in the comments, and let's see how much code Dart 3.13 and BlocSignal can shave off!

Ready to build boilerplate-free reactive apps?

Check out the full documentation, benchmarks, and interactive examples at blocsignal.dev or star the open-source repository on GitHub!

Hello Folks!

Operating at Azure scale means managing change across multiple interconnected systems. As applications, services, and dependencies evolve, resilience becomes a foundational design principle rather than an afterthought. In this Microsoft Azure Infra Summit 2026 session, Bhavana Konchada, Principal Software Engineer at Microsoft and lead architect of the Resilience Control Platform, takes us behind the scenes of a production-grade resilience platform built on Azure and explains the engineering choices that helped bring it to life.

Why IT Pros Should Care

Most of us have shipped a system that worked beautifully on day one and then quietly fell apart the first time something downstream blinked. Bhavana’s session is a brutally honest tour of the decisions you make early that determine whether your platform survives reality. Here’s what you walk away with:

• A pragmatic blueprint for service boundaries that you can actually operate at 2 a.m.
• Concrete Durable Functions patterns (Monitor, continue-as-new, idempotency) that keep long-running workflows healthy.
• A Cosmos DB partitioning strategy grounded in real access patterns, not gut feel.
• A multi-region, fail-and-continue mindset (instead of fail-and-recover) that holds up when a region disappears.
• Real lessons from production, including the “non-deterministic orchestration” outages nobody warns you about.

In short, if you build, run, or modernize platforms on Azure, this session reshapes how you think about reliability.

What DR by Design Actually Means, a Technical Overview

Bhavana frames the Resilience Control Platform as five chapters: architecture and service boundaries, orchestration with Durable Functions, the Cosmos DB data layer, identity across multiple user realms, and the resilience playbook itself.

The platform has four moving parts:

• A portal where operators define and monitor scenarios.
• An orchestration engine that executes long-running workflows.
• Cosmos DB as a shared persistence layer.
• Downstream infrastructure APIs the engine acts on.

The big “DR by Design” idea is that resiliency isn’t bolted on later. It’s a property of every choice from boundaries upward. As Bhavana puts it, you stop designing for “fail and recover” and start designing for “fail and continue.” Users don’t know (or care) which region runs their workflow; they just need it to run reliably, consistently, and without interruption.

How It Works, Under the Hood

Bhavana’s team made several deliberate design moves worth borrowing.

Arm’s-length service boundaries. Version one had the portal and orchestration engine tightly coupled with shared dependency injection and a shared database context. It felt clean until they tried to operate it. Now the two services talk over REST contracts, each with its own dependencies. Yes, that means a bit of duplicated code. What they gained, independent deployments, isolated failures, and clear ownership, more than paid for it.

The right runtime for the workload. The portal is a session-driven web app, so it lives on App Service. The orchestration engine bursts on demand and runs workflows for minutes (sometimes hours), so it’s built on Durable Functions. Forcing both into one model would have looked simpler on paper and been worse in practice.

Accept Fast, Process Asynchronously. Clicking Execute returns a 202 immediately. The orchestrator does the heavy lifting in the background and updates status in Cosmos DB. The portal just reflects progress. Users never wait on long workflows.

Durable Functions patterns that actually scale. Three lessons stood out:

• The Monitor pattern replaces busy polling with durable timers. The orchestrator wakes up, checks status, and goes back to sleep without holding compute.
• Orchestrators are state machines, not scripts. Calling DateTime.UtcNow inside an orchestrator produces non-deterministic replay and random production failures. The fix is to use the orchestration context for time and IDs.
• Continue-as-new keeps replay history bounded. Long-running orchestrations otherwise spend more time replaying history than doing real work.

Cosmos DB designed around access, not org charts. Partitioning by tenant feels logical and creates hotspots the moment one tenant gets busy. The team partitions by entity (each plan owns its partition) and uses hierarchical keys combining plan ID and execution ID. They also lean on TTL for data lifecycle so completed records expire automatically, no cleanup jobs required.

Identity as an execution boundary. Corporate users authenticate through Microsoft Entra with OpenID Connect. Operations users come in through a federated WS-Federation system. Instead of forking the app, the team built home realm discovery at the front door, normalized everything into a single identity model behind it, and added custom middleware in the Azure Functions isolated worker model to extract, validate, enrich, and fail-fast on every token. Authorization is config-driven so every endpoint gets the same treatment.

Multi-region from day one. The full stack (portal, engine, APIs, supporting services) runs in parallel across regions, fronted by Azure Front Door as the global entry point. Health probes drive automatic regional failover with no human in the loop.

Cosmos DB single-write with automatic failover. Multi-write looks attractive on a slide and introduces real conflict-resolution complexity. The team chose one primary write region plus a replica with automatic failover. The Cosmos SDK detects region unavailability and routes requests to the promoted region without application code changes.

Idempotency from day zero. Once you have retries (and Front Door, the SDK, and your clients all retry), every operation has to be safe to run more than once. Client-provided IDs, Cosmos conflict detection (a 409 means “already succeeded”), and idempotent orchestration events make sure the same outcome lands no matter how many times a signal arrives.

Real-World Value, Use Cases, ROI, Scenarios

What does this buy you in practice?

• Scenario validation under stress without compromising production. The platform is built to proactively validate and govern system behavior at scale.
• Long-running workflows that survive everything. Host restarts, transient downstream errors, regional failovers, none of them lose work in flight.
• Predictable cost. Durable timers and continue-as-new mean you stop paying for compute that’s only waiting.
• Operability at scale. Independent services, clean contracts, and centralized identity all mean a smaller cognitive load when something breaks at 2 a.m.
• Honest tradeoffs. Single-write Cosmos loses theoretical write latency in the second region and gains predictable behavior, no conflict ambiguity, and far easier debugging during failovers. That’s usually the right trade.

In short, the platform behaves the same on a quiet Tuesday and during a regional outage. That’s the whole point.

Getting Started

You don’t need to build the Resilience Control Platform tomorrow. You can start applying these patterns this week.

1. Map your service boundaries honestly. If two services share a DI container or database context, decouple them behind a REST contract.
2. Pick runtimes by workload, not by consistency. Interactive UI on App Service; long-running orchestrations on Durable Functions.
3. Adopt the 202-Accepted pattern for anything that could take more than a couple of seconds.
4. Audit your Durable orchestrators for DateTime.UtcNow, Guid.NewGuid, and direct HTTP calls. Move them into activities, use the orchestration context for time and IDs, and apply continue-as-new on long loops.
5. Revisit your Cosmos partition keys against actual access patterns and enable TTL for transient data.
6. Stand up a second region behind Azure Front Door, enable Cosmos DB automatic failover, and make every write operation idempotent with client-provided IDs.

Resources

• Reliability design principles, Azure Well-Architected Framework
• Durable Orchestrations overview
• Azure Durable Functions documentation
• Azure Functions documentation
• Hierarchical partition keys in Azure Cosmos DB
• Azure Cosmos DB documentation
• Azure Front Door documentation
• Microsoft Entra ID documentation

Keep Learning at the Summit

Catch the full Microsoft Azure Infra Summit 2026 session playlist here

Cheers!

Pierre Roman

This week, we discuss Zuckerberg's open source AI manifesto, GPUs as securitizable assets, and who actually gets AI ROI. Plus, Buc-ee's goes to war over beavers.

Watch the YouTube Live Recording of Episode 585

Runner-up Titles

• Law of Unintended Consequences
• We’re not lawyers, we just have common sense
• Trillion-dollar open source company
• The Meta Manifesto
• I don’t think self-awareness is their strong point.
• Using AI to fight AI
• Put me as a strong maybe.

Rundown

• Days after John Oliver's dare, Buc-ee's sues again
• Meta's Big AI Week
  • The Future is for Everyone
  • Meta Unveils ‘Open Source’ Version of Its Most Powerful A.I. Model
  • Meta debuts first AI coding agent to take on Anthropic and OpenAI
  • Superintelligence is a dragon
  • Mistral Is in the Right Place at the Right Time
• The AI Money Machine
  • Nvidia lines up $500 billion in financing as CEO Jensen Huang tells CNBC his chips are ‘investable asset’
  • 48% of Google Cloud Revenue Next Year Could Come From Just 2 Companies That Have Still Never Turned a Profit
  • Datadog Says Lower Usage From Major AI Customer Could Dent Growth

Relevant to your Interests

• New Orleans will use AI to answer 911 calls instead of a human
• OpenAI's new AI smart speaker will reportedly sell for between $300 and $400 TechCrunch
• OpenAI acquires presentation startup NextSlide
• A road trip through the data center debate
• A Top OpenAI Executive Steps Down
• Cloudflare OS: an open platform for agents, apps, and work
• Introducing Kitesurf: The agent-first browser that runs in V8 isolates on Cloudflare Workers
• The next generation of MCP
• How a simple request for AI to book a gym class exposed a major threat

Nonsense

• Buc-off

Sponsors

• Signadot: making sure AI-written code actually works.

Conferences

• WeAreDevelopers NA, Sept 23-25, 2026, Discount Code: DEVPOD50
  • 25 Free Tickets
• AI Connect, Aug 22nd, 2026 - Riga, Latvia, Coté speaking.
• DevOpsDays Graz, Sept 4-5, 2026
• Cloud Foundry Summit, Sept. 21st to 22nd, Heidelberg, Coté speaking.
• DevOpsDays Rockies, Sept. 22 – 23, 2026, Discount Code: 26DODSWEDEFTALK
• DevOpsDays Dallas, Sept 28-29, 2026
• DevOpsDays Vilnius, Sep 30 - Oct 1, 2006
• DevOpsDays Istanbul, Oct 24th, 2026, Coté keynoting.
• VMware User Group, Orlando, Oct 20-22, 2026
• Cloud Native Denmark, Nov 19th, 2026, Copenhagen, Coté keynoting.
• SCALE 24x Pasadena, CA, April 1-4, 2027

SDT News & Community

• Join our Slack community
• Email the show: questions@softwaredefinedtalk.com
• Free stickers: Email your address to stickers@softwaredefinedtalk.com
• Follow us on social media: Twitter, Threads, Mastodon, LinkedIn, BlueSky
• Watch us on: Twitch, YouTube, Instagram, TikTok
• Book offer: Use code SDT for $20 off "Digital WTF" by Coté
• Sponsor the show
• Sponsor more podcasts with Failover Media

Recommendations

• Brandon: Furious on Hulu
• Matt:
  • NearbyWiki
  • Reading Maps
  • Infrastructure Frontiers podcast
• Coté:
  • IncomphrensibleMedia.com
  • Elgato Teleprompter
  • TelepromterPro+

Sponsored By:

• Signadot: AI writes code. Signadot make sure it works.
• WeAreDevelopers US: WeAreDevelopers World Congress North America Sept 23–25, San José, CA Promo Code: DEVPOD50

Copilot is getting simpler. Not “more features” simpler – but one app simpler.

Microsoft is bringing the Microsoft 365 Copilot app and the personal Copilot experience together into a single app, with a simpler name, a new icon and a new web address: copilot.cloud.microsoft. The rollout starts mid-August 2026 (MC1454108), so this is happening right now, not “sometime later this year”. Copilot is embedded onto Microsoft 365 more and more, enabling AI across experiences. Just think how SharePoint is a platform providing content management in Microsoft 365, Copilot is becoming an AI platform providing AI in the same way.

One app for work and personal

Like the other Microsoft 365 apps, Copilot moves to a single app experience across personal and work accounts. You will keep switching between your Microsoft Entra ID (work or school) account and your Microsoft account (personal) with the same account switcher in the navigation pane you use today.

What is new is that the app makes it much more obvious where you are:

• A different background color for each account type
• A “Work” label under your user profile in the navigation pane (web and desktop apps)
• The familiar green data protection shield stays in the work experience

The number one question I will get from customers about Copilot is still “but is this the safe one?” – and answering that with colors and a label beats answering it with a 20-slide deck. If your organization allows personal account sign-in, users will also be able to sign in with their Apple or Google credentials to reach their Microsoft account.

New name and new icon

The Microsoft 365 Copilot app becomes simply the Microsoft Copilot app, with a refreshed icon. Small thing on paper, big thing in practice: every screenshot in your adoption material, every “click the Copilot icon here” instruction in your training deck, and every intranet page is suddenly a little bit out of date. ( Note to myself: update my own slides before the next session!)

The URL changes to copilot.cloud.microsoft

The web app moves from m365.cloud.microsoft to copilot.cloud.microsoft, with automatic redirection. Timeline from the message center:

• Mid-August 2026 – worldwide rollout begins for mobile and web apps. Opt-in early access begins for Windows and Mac. The new URL is also available in Frontier for testing.
• Late August 2026 – standard rollout of the URL redirect begins.
• Mid-September 2026 – worldwide rollout for Windows and Mac apps.
• Late September 2026 – deferred rollout of the URL redirect for the web app.

The important part for the networking and security people: the new address stays under the *.cloud.microsoft domain, so it inherits the same security, compliance and enterprise allow-listing properties. If you followed the recommended network configuration for Microsoft 365 Copilot, you do not need to make additional network changes.

What does NOT change

This is the section I would put in your user communication, word for word:

• No changes to enterprise security, compliance, privacy or government controls.
• Data entered in the personal experience does not flow into the work experience – and data in the work experience does not flow into the personal one.
• The Application ID is not changing, so existing policies keep working.
• Admins can still limit Microsoft account (personal) access with Tenant Restrictions.
• The account switcher works exactly like today.

Despite it feeling like a big platform change, it really is not. It is a name, an icon, a URL and better visual cues.

What admins should actually do

A short, honest to-do list:

1. Tell your users – updated name, icon and URL start showing up from mid-August 2026. This is the single thing that prevents helpdesk tickets.
2. Update your internal material – training, adoption pages, help articles and anything referencing the old app name, icon or the m365.cloud.microsoft URL.
3. Check your Recall filters. If you applied a group policy that filters the former Microsoft Copilot app out of Recall snapshots, that policy does not automatically carry over to the new Microsoft Copilot app. You need to set it up again for the new app. This is the one I would not skip.
4. Consider the branded footer – when available later this month, adding a branded footer helps users recognize the work or school experience. It only shows in the Microsoft Entra ID experience (see MC1238432 for timing and setup).
5. Test the desktop app early if you want – opt-in deployment to a test group will be possible before September GA. Opt-in early access is not available for special cloud environments yet.

And there is more happening in Copilot right now

This app update did not arrive alone. From the same message center batch, a few things worth having on your radar:

• Simplified access to Copilot Chat on mobile (MC1454386) – two legacy mobile-only controls stop restricting Copilot Chat on iOS and Android, so mobile access finally matches web and desktop. On by default, rolling out mid-August to late September 2026.
• Word document summarization is moving (MC1454113) – the Top of Doc summarization experience moves to other Copilot surfaces in Word, including a proactive “Summarize this document” suggestion. The capability stays, only the way you reach it changes. Rollout begins late August 2026.
• Agent Builder gets simpler (MC1454377) – new agents will have capabilities enabled by default, the knowledge configuration experience is updated, and “Uploaded Files” is renamed to Attachments. Existing agents are not impacted. Late August 2026.
• Copilot Tuning moves to Microsoft Copilot Studio (MC1454393) – a skill-based architecture, with tuning temporarily paused for selected Agent Builder templates and the Optimization template retired. Public Preview September 2026, GA December 2026.
• The =COPILOT function in Excel is retiring (MC1454373) on September 14, 2026. If you played with it in Insider or Frontier – and I of course tested it out – it is back to the Copilot side pane. A bit of a shame, honestly.
• Learning Coach Agent is retiring (MC1454391) in the first week of October 2026 – transition users to Learning Agent before that. Nicely timed with AI Skills Navigator content coming into Learning Agent (MC1454381), rolling out mid-to-late August 2026.
• Copilot Analytics Labs (MC1454388, MC1454387) – a new self-service hub under Resources with templates, sample code, prompts and research for measuring Copilot adoption and ROI, including an All-in-One Dashboard and a Cowork Value Estimator. If you are being asked “so what is the value?”, start here.

Reference table

So what does this mean?

One app. One name. One icon. One place to go. Copilot is essentially becoming more and more a platform, that enables AI in all around Microsoft 365.

For years we have been explaining to people which Copilot is which, and drawing little diagrams about where their data goes. That explaining does not disappear completely – but the app is now doing a big part of it for us, with a color and a label instead of a slide.

Images from Message Center message MC1454108.

Tech conferences are worth every hour I have ever given them. The sessions are not. So instead of spending a thousand words proving that first, here is the program for a conference that does not exist.

One note before I start. None of this is about any particular event, any particular organizer, or anybody I have worked with. There is no conference I have in mind and no person I am describing. It is all a composite, drawn from twenty years and a lot of countries, and every criticism is aimed at the format rather than at the people who run it. If something here sounds like your event, that is because it is common everywhere, not because it is you. I owe tech conferences my entire career, and I would like them to still be here in twenty years. That is the only reason any of this got written down.

The Program

• 08:00 Registration. Your badge says what you are stuck on, not where you work.
• 08:45 The follow-up keynote. Last year’s speaker returns and reports what actually happened.
• 09:30 Twelve minutes, then forty-eight. Every talk capped at twelve. The rest of the hour belongs to the room.
• 10:30 Coffee. No microphone anywhere, so nobody says “more of a comment really.”
• 11:30 Bring your own problem. No call for papers. The agenda was built from what attendees submitted.
• 12:30 Lunch is assigned. You are seated by the problem printed on your badge.
• 14:00 The clinic. Bring your worst thing. Public triage on a big screen.
• 15:00 Office hours. No talks at all. Bookable appointments with the experts.
• 16:00 The autopsy. Cameras off. One failed project, in detail, including what it cost.
• 17:00 The transparency hour. Rates, salaries, real numbers. Moderated and anonymous.
• 18:00 The reverse expo. The attendees get the booths. The vendors walk the floor.

Day two is deliberately boring. A ten year room, where nothing on stage has been in production for less than a decade. A sunset track about deprecating and deleting. A rule that no number leaves the stage without a source. Certification you earn by doing the task in front of a human being.

I’d pay for that.

Some of This Exists. Almost None of It Is the Main Event.

Most conference criticism ends up recommending an unconference, a hallway track, or a birds-of-a-feather session. I have sat through all three and they all help, and every single time they get put in a side room near the toilets while the main hall carries on exactly as before.

Several of the things below already run somewhere, as an add-on, a lounge, or an experiment on the third floor. I have never seen one of them put at the center of an event and made the reason people came.

That program is me being polite. Here is what I would do, and some of it would cost me personally.

Delete the sessions. All of them. No stage, no deck, nothing to sit through. Three days of appointments instead. Fifteen minutes with the person you flew there to meet, booked like seeing a doctor.

I’ve made a living on those stages for twenty years and I’m telling you to switch mine off. In twenty years, not one person has ever come up to me afterward to talk about slide fourteen.

Nobody has ever gone home and said the best part was the slides.

If that is too far, cap every talk at twelve minutes. You’ve sat through the other version. Agenda slide. Definition slide. A brief history of the problem. A diagram with too many arrows. Then the demo you flew in for, arriving with six minutes left while somebody at the back holds up a card that says five.

The good part never ran longer than ten minutes. We have been renting ballrooms by the hour to protect the other fifty.

Print the badges wrong on purpose. Take the job title off. Put what is grinding them down.

“Moving forty terabytes off a database nobody wants to touch.”

“Cannot get anybody to care about our test suite.”

Notice how fast you picked which one to walk up to. You may already know the answer.

That is one column in a spreadsheet, and it does more work than the job title ever managed. Nobody in the history of conferences has crossed a room because a badge said Senior Manager.

Assign the lunch. Ninety minutes, already paid for, currently handed to whoever was standing near you when the room emptied.

Think about the one conversation that changed how you work. Somebody put you next to the right person by accident. Stop leaving your best introduction to luck.

Schedule nothing. On purpose. Ninety minutes in the middle of the day with no rooms open, no track, and nowhere to be.

Every organizer fills that gap, because an empty box on a printed grid looks like a mistake. That empty box holds the story you will still be telling in five years. Guard it the way you guard the keynote.

Nobody speaks alone. Every talk pits two people who genuinely disagree against each other, with nobody there to smooth it over.

Think about how much of a talk stays with you when you agreed with all of it. Now think about the last time you watched two people properly disagree in public. You can probably still name who you thought won.

The retraction track. Speakers come back and publicly retire the advice they no longer believe.

I’d go first, and I wouldn’t enjoy it. I have said things from a stage that I wouldn’t say today, and some of you went home and built on them. I’ve never apologized for that. Nobody does. We just quietly stop mentioning it and hope the search results move on.

We give people a stage to make a promise, and then never ask them back to keep it.

Mail the promise back in ninety days. On the last afternoon everybody writes one sentence about the thing they are going to change. The organizer posts it back three months later.

Picture that envelope landing on an ordinary Tuesday, in your own handwriting, long after you stopped thinking about it.

Price the corridor higher than the sessions. Two tickets. One gets you whatever talks survive. The other gets you the matching, the lunch, the appointments and the room with the cameras off, and it costs twice as much.

If I am right, that is the one that sells out. If I am wrong, one event finds out cheaply, I look silly, and at my age that is a fair trade.

Put a refund on it. Leave unable to name one thing you will do differently, and get your money back.

Almost nobody would ask, because we all want to believe we learned something. A refund clause is a promise that we did.

Other Industries Solved This Forty Years Ago

I stole the thinking below. Every field that has ever needed people to talk properly got there before us. Medicine, manufacturing, teaching hospitals, courtrooms, design schools. They worked it out decades ago and wrote it down.

We are the industry that automates everything, and our answer is still a person, a projector, and hope.

Room size changes how people behave. We have exactly one setting. Here are nine that cost almost nothing.

The first one is the one to try tonight. It’s horrible for about a minute, and then somebody leans forward and argues with somebody else about your situation, and you realize nobody in the room is defending anything.

The card tables are the one I am least sure about. Half of them might sit empty all afternoon, and that would be a very public kind of failure.

We have spent thirty years automating everything except the one hour where people are actually in the same room.

And this is the moment for it. Travel is expensive, attention is cheap, and a machine will summarize any talk you can name before you reach the car park.

A screen can now copy nearly everything we used to get on a plane for. It still cannot do very much with forty people standing in the same room, which is the only advantage we have left.

Now Name Three Sessions

Think about the last conference you actually attended. Name three sessions.

You have one. Maybe two, and you are not confident about the second because it might have been a webinar.

The speakers weren’t the problem. They worked hard, and I know how hard, because I have been the one rewriting a demo at eleven at night on terrible hotel wifi with a laptop balanced on an ironing board.

Now go back to that same conference and name three conversations instead.

You did that faster, didn’t you.

I have forgotten every slide I have ever seen. I have not forgotten a single hallway.

The Bill, and Who Pays It

For thirty years the old shape worked, because there was no other way to reach knowledge that scarce. Content is now free, infinite and searchable, and it is not going back up.

The introduction, the argument over dinner, the person who says I have seen this before and here is what actually happened, turns out to be the only part nobody can download.

We are charging for the free half and giving away the priceless half as a bonus.

Sponsors fund the event. Sponsors are buying attention. Attention is now cheaper to buy somewhere else. So the funding leaves.

Ignore the attendance number on the closing slide, that is marketing. Go and count the booths instead, and count how many of them are a table, a pull-up banner, and one person whose budget got cut in half back in March.

I own a drawer of conference socks. I have never once bought the software.

No sponsors at all. Attendees pay real money, speakers get paid, no vendor keynote and no gold tier. A smaller event, where every slot on the agenda earned its place on merit.

Publish the speaker terms. State what is covered before the call opens. Flights, nights, fee, or nothing at all.

Speaker pay is easy to rage about and easy to get wrong, so slow down here. There is no single arrangement. There are four or five, and they all sit side by side at events of roughly the same size and reputation. The exchange runs both ways too. A well known speaker fills rooms and shifts tickets, and in return picks up an audience and a few consulting leads. I have turned down paid slots at the wrong event and paid my own way to the right one, and there was nothing noble in that. I did the sums and the right room was worth more to me than the fee.

Two speakers on the same stage can be on entirely different terms, and neither of them knows.

I don’t think any of that is unfair. I think it just never gets said out loud, which is a far smaller problem, and one that costs an organizer nothing to solve.

While we are being honest about evidence, I should admit that there is not one sourced figure in this entire post. By my own rule you should discount all of it accordingly.

The Volunteers Are Running Out

The big commercial events will be fine. They have staff and a finance team. I’m worried about the volunteers.

Somebody held every event you have loved together on their own vacation days, working harder than they do at their real job. They chased the catering. They printed the badges at home the night before, the printer jammed at eleven, and they fixed it. They stood at registration at seven in the morning with a real smile on four hours of sleep.

Nobody paid them. Nobody thanked most of them.

I’ve never done that job. I’ve only ever benefited from it.

Every good thing in this industry was built by somebody who was tired.

They are running out, and not because they stopped believing in it. There is only so much of this a person can do on top of a full time job. When they stop, nothing collapses loudly enough for anybody to notice. It just does not happen next year, and everybody assumes somebody else made that call.

That’s the loss I actually worry about, far more than a thinning expo hall. One person with a laminated schedule, and nobody behind them.

My Badge Would Say

My first talk drew about eleven people, and four of them were waiting for the next session.

My hands shook. I read half of it off the slides. I finished early, so I stood there offering to answer questions nobody had asked.

Somebody stayed behind anyway. We talked for twenty minutes. I’ve known that person ever since.

That’s the entire business model of my life, and it happened in a corridor.

So scratch the nostalgia label off this. Conferences are not dying, whatever the posts say. They are being asked what they are actually for, probably for the first time in thirty years.

You fly home full of intentions, and eleven days later you couldn’t name one thing you were going to change. The notebook is in a drawer with four pages used. Call it the eleven day rule. Every idea above exists to beat it.

I do not want the conference back. I want what the conference was for.

That question, what is still worth paying for once the information itself is free, is the one running underneath all thirty essays in my book AI: Nobody’s in There. But we’re still in here. Every essay is free to read in the complete online collection, and there is a paperback on Amazon if you would rather hold something real.

And if somebody printed my badge the way I described at the top, mine would not say author, or consultant, or speaker.

It would say: still hoping somebody stays behind after the talk.

Thank you for the twenty years. Now let us go and ruin the agenda.

This is not a story about fixing tech conferences, it is a story about finally charging for the part that was always worth the trip.

Reference: Pinal Dave (https://blog.sqlauthority.com/), Tech Conferences, X

First appeared on Tech Conferences Are Worth It. The Sessions Are Not.