The “next big thing” in space technology is a shift from simply getting to space to living, working, and computing there. We are transitioning from an era dominated by one-off scientific launches to a mature, commercial space economy focused on infrastructure, scalability, and Earth-facing benefits.
The most transformative advancements driving this Next Space Age include:
In-Orbit Servicing & Orbital Refueling
Historically, a satellite’s lifespan was strictly limited by how much fuel it carried at launch. Once out of fuel, a multi-million-dollar asset became space junk.
The Tech: Companies like Orbit Fab (developing “gas stations in space”) and Astroscale are actively pioneering orbital refueling and servicing systems.
Why it matters: In-orbit refueling fundamentally changes the economics of space. It enables “maneuverable” satellites that can change orbits to dodge debris or threats, dramatically extends the lifespan of space assets, and is the absolute prerequisite for massive, deep-space vehicles (like SpaceX ’s Starship) to reach the Moon and Mars.
Edge Computing and Data Centers in Space
Satellites generate mind-boggling amounts of data, but transmitting raw files back to Earth requires immense bandwidth.
The Tech: Companies are beginning to construct and deploy space-based data centers and software-defined satellites equipped with advanced AI chips.
Why it matters: By processing data “at the edge” (directly in orbit), satellites can filter out useless data (like cloud cover in Earth images) and only transmit the crucial insights. This reduces latency and bandwidth strain, enabling near-instantaneous decision-making for disaster response, military operations, and climate monitoring.
Direct-to-Device (D2D) Satellite Connectivity
The gap between cellular networks and satellite communication is rapidly disappearing.
The Tech: Instead of needing a heavy, specialized satellite phone or a dish (like Starlink), new low Earth orbit (LEO) mega-constellations are successfully integrating with standard consumer smartphones.
Why it matters: This technology eliminates cellular “dead zones” globally. Whether you are in the middle of the Pacific Ocean or deep in a desert, your everyday smartphone will be able to connect directly to a satellite for emergency services, texting, and eventually, voice and data.
Microgravity Manufacturing (Space Factories)
Some materials simply cannot be made properly on Earth because gravity interferes with their molecular structures.
The Tech: Companies like Varda Space Industries and Redwire are constructing automated “space factories” designed to manufacture goods in microgravity and return them to Earth.
Why it matters: Manufacturing in orbit allows for the creation of flawless semiconductors, incredibly pure fiber-optic cables (ZBLAN), advanced pharmaceuticals with perfect crystal structures, and even 3D-bioprinted human organs.
The Transition to Commercial Space Stations
The International Space Station (ISS) is approaching its retirement. Rather than building another government-run station, the private sector is stepping up.
The Tech: Private companies are building commercial orbital platforms. Startups like Vast (with its Haven-1 module), alongside aerospace giants building platforms like Starlab and Orbital Reef, are leading this charge.
Why it matters: These private stations will act as multi-purpose business parks in orbit, leasing out space for corporate research, space tourism, and the aforementioned microgravity factories.
Next-Gen Nuclear Propulsion
Standard chemical rockets are highly inefficient for deep-space travel. To make Mars or sustained lunar bases viable, we need better engines.
The Tech: Major investments are being poured into Nuclear Thermal Propulsion (NTP) and Nuclear Electric Propulsion (NEP).
Why it matters: Nuclear rockets utilize fission to heat propellants, offering twice the efficiency of chemical rockets. This would slash transit times to Mars from nine months to just three or four, drastically reducing astronauts’ exposure to harmful deep-space radiation and microgravity muscle degradation.
Summary
If the last decade of space tech was defined by cheaper launches (thanks to reusable rockets), this next era is defined by utility. Space is no longer just a destination – it is fast becoming the ultimate platform for Earth’s digital and industrial infrastructure.
When people describe AI as “thinking,” they often imagine something brain-like happening inside the model. That intuition is not completely wrong, but it can also be misleading. A useful way to think about modern AI is that it operates in a kind of high-dimensional meaning space: a “J-space,” or more commonly, a latent or embedding space, where words, images, concepts, patterns, and relationships are represented as mathematical positions and directions.
The human brain also seems to build internal spaces of meaning. We do not store the word “apple” as a dictionary entry alone. We connect it to taste, color, childhood memories, gravity, orchards, nutrition, symbols, jokes, and maybe the smell of an autumn kitchen. Both AI systems and human brains compress the world into internal representations. But the way they form, use, and experience those representations is profoundly different.
The Similarity: Both Build Maps Of Meaning
Modern AI models do not understand text as flat strings. They convert tokens, images, sounds, or other inputs into vectors: long lists of numbers that place those items inside a high-dimensional space. In that space, related things tend to sit near each other. “King” and “queen” are closer than “king” and “toaster.” A medical symptom may cluster near related diagnoses. A trading term like “liquidity” may sit near market depth, spreads, order books, and volatility.
The brain appears to do something comparable, though biologically rather than mathematically. Neurons fire in patterns. Groups of neurons encode features, associations, expectations, and sensory memories. Our mental model of “dog” is not stored in one neuron; it emerges from distributed activity across many systems: vision, language, emotion, memory, motor response, and social experience.
So at a high level, both AI and brains create internal maps. These maps let them generalize. If an AI has learned relationships between “forms,” “fields,” “validation,” and “workflow,” it can reason about a new text-to-form system it has never seen before. If a person has seen enough financial applications, they can understand a new trading UI without reading every line of documentation.
That is the first real similarity: intelligence needs compression. Neither AI nor humans can keep every detail of the world in raw form. Both need internal structures that preserve what matters.
The Difference: AI’s Space Is Mathematical, The Brain’s Space Is Lived
The biggest difference is that AI’s J-space is not experienced. It is not conscious. It has no body, no pain, no hunger, no embarrassment, no delight, no fear of being wrong in front of a room full of people. Its representations are powerful, but they are not lived from the inside.
A human concept is embodied. “Hot” is not merely close to “fire” in a semantic field. It is connected to skin, reflex, danger, comfort, coffee, fever, memory, and survival. “Market crash” is not just a pattern of words; for a trader or technologist in financial services, it may carry stress, institutional memory, regulatory implications, and the muscle memory of incident response.
AI can model those associations statistically. It can write convincingly about them. But it does not feel the stakes. It predicts and transforms patterns; it does not inhabit them.
That difference matters because human intelligence is not only pattern recognition. It is pattern recognition tied to consequence.
AI Learns From Artifacts; Humans Learn From Being In The World
AI models are trained on data: text, images, code, audio, video, logs, documents, and other artifacts humans or systems have produced. That gives AI access to enormous breadth. It can absorb patterns across medicine, law, software, finance, literature, and history at a scale no human can match.
But humans learn by acting in the world. A child does not learn “cup” only by reading millions of sentences about cups. They grab one, drop it, spill from it, see someone react, and gradually build a concept that blends physics, language, social behavior, and intent.
This is why AI can be strangely brilliant and strangely brittle. It may explain an architecture pattern beautifully, then make a basic mistake about the operational reality. It may generate a plausible workflow that ignores the messy constraints of real organizations: permissions, incentives, audits, legacy systems, procurement, fear, politics, and fatigue.
The brain is slower and narrower, but it is grounded. AI is broad and fast, but often indirect.
AI’s J-Space Is More Inspectable, But Less Understandable
There is an interesting paradox here. AI representations are, in one sense, more inspectable than the brain. We can look at vectors, activations, attention patterns, embeddings, and model weights. We can probe them, visualize them, cluster them, and compare them.
But that does not mean we fully understand them.
A neural network may contain billions or trillions of parameters. Its “knowledge” is not stored as tidy facts. It is smeared across the system. Similarly, the human brain does not have a clean folder labeled “childhood,” another labeled “C#,” and another labeled “fear of public speaking.” Both systems are distributed and emergent.
Still, there is a difference in kind. Brain activity is part of a living organism with goals, homeostasis, emotion, and self-preservation. AI activation is computation inside an engineered system. Both are complex, but they are complex in different ways.
The Brain Has Memory; AI Has Context
Humans have durable autobiographical memory. We remember who we are, what happened to us, what we regret, what we want, and what we promised. Memory shapes identity.
AI models have something more limited. A model has trained knowledge baked into its parameters, and during a conversation it has context. Some systems may also have external memory tools, retrieval systems, profiles, or databases. But this is not the same as human memory. It is more like a combination of pattern recall, document retrieval, and temporary working context.
That difference changes everything.
A human remembers not only information, but meaning. “I failed at this before” changes how a person approaches a problem. “My father taught me this” changes how a memory feels. “This community trusted me” changes how a leader behaves.
AI can be given those facts. It can reason over them. But it does not become accountable to them in the human sense.
Creativity: Similar Shape, Different Source
AI creativity often looks like movement through J-space. It combines distant concepts, finds analogies, completes patterns, and generates variations. Ask it to connect open source governance, financial regulation, and agentic AI, and it can produce something useful because those regions of meaning can be mathematically traversed and recombined.
Human creativity also involves connecting distant ideas. But it is powered by intention, taste, frustration, memory, risk, and identity. A person creates not only because an association is possible, but because something matters.
That is why AI is excellent for ideation, synthesis, drafting, and reframing. But the strongest results usually come when a human provides judgment: “This is too generic.” “This misses the politics.” “This sounds clever but not true.” “This is the sentence that matters.”
AI can generate. Humans can care.
Why The Comparison Still Matters
Even though AI is not a brain, comparing AI’s internal spaces to human cognition is useful. It helps us understand why AI can generalize, hallucinate, surprise us, and fail in non-obvious ways.
It also helps us design better systems. If we know AI works through representations rather than lived understanding, we should give it grounding: tools, retrieval, feedback, constraints, examples, tests, and human review. In regulated domains like finance, healthcare, and law, this is not optional. A fluent answer is not the same as a correct answer. A confident pattern is not the same as accountable judgment.
The future is not about pretending AI is a human brain. It is about understanding what kind of intelligence it actually is.
Conclusion
AI’s J-space and the human brain are similar in that both create internal maps of meaning. Both compress complexity. Both use distributed representations. Both can generalize from prior patterns to new situations.
But they are not the same. AI’s space is mathematical, trained, and computational. The brain’s space is biological, embodied, emotional, and lived. AI has representations without experience. Humans have experience that gives representations weight.
That distinction is not a reason to dismiss AI. It is a reason to use it well.
AI is not a synthetic brain. It is a new kind of cognitive instrument: a machine that can navigate meaning at scale, but still needs human grounding, human context, and human judgment to turn pattern into wisdom.
AI is rapidly becoming a new class of “developer inside the organization”, not just writing code, but navigating repositories, understanding conventions, reusing components, and stitching together systems. That makes a quiet but important question suddenly urgent: how do we make AI a good consumer of inner source?
Inner source promises open-source style collaboration inside the enterprise: shared repositories, reusable components, transparent contribution flows, and cross-team ownership. But most of that was designed for humans. AI agents don’t naturally understand social contracts, repo norms, or the “tribal knowledge” that keeps inner source ecosystems coherent. If we want AI to be useful here, we need to redesign the interface between agents and codebases.
1. Treat inner source as a product surface, not just a codebase
Most inner source initiatives fail for AI consumption because they expose repositories, not intent.
Humans can infer:
“This repo is the canonical implementation”
“This folder is deprecated but still used”
“This library is preferred over that one in finance apps”
AI cannot reliably infer that unless it is explicitly encoded.
Usage guidance (“use this for new builds, not legacy wrapper X”)
This is where initiatives like the FINOS ecosystem are relevant, because they already enforce structured governance across financial open source components, which is exactly the kind of signal AI systems need.
2. Make conventions machine-readable, not just documented
Most organizations rely on README files, wikis, and architecture pages. That works for humans who can interpret ambiguity. It fails for agents that need deterministic structure.
To make inner source AI-consumable:
Move conventions into structured formats (YAML, JSON, CODEOWNERS++, ADR metadata)
Encode architectural decisions as queryable artifacts (not prose)
Standardize “how to use this repo” into schema-driven manifests
Think of this as upgrading from:
“Read the wiki before contributing”
to:
“Query the repo for its rules of engagement”
3. Give AI a semantic map of the ecosystem
A single repository is easy. An inner source ecosystem is not.
AI agents need a graph, not a folder tree:
Dependency relationships between services
Component reuse graphs (who uses what)
Domain boundaries (payments vs risk vs onboarding)
Critical paths (what breaks trading systems vs what is cosmetic UI)
This is where code intelligence platforms and tools like GitHub’s ecosystem (especially with advanced code search and dependency graphing) become foundational. Without a semantic map, AI will “hallucinate architecture” by guessing.
4. Use MCP-style connectors to standardize access patterns
A major step forward in agentic systems is the rise of structured tool interfaces, such as the Model Context Protocol (MCP). The key idea is simple: instead of letting AI scrape repositories, you give it tools.
For inner source, this means:
search_components(domain=”risk”)
get_recommended_library(use_case=”charting”)
validate_usage(pattern=”trading-ui-grid”)
find_owner(service=”pricing-engine”)
This turns inner source from passive code storage into an interactive system of APIs for developers and agents alike.
5. Encode “trust and safety” as first-class signals
In regulated environments (especially financial services) AI consuming inner source cannot be neutral. It must understand:
What is production-safe
What is experimental
What requires review or approval
What is prohibited for certain environments
Without this, AI will confidently suggest technically correct but operationally unsafe patterns.
This is where governance frameworks from organizations like FINOS become particularly relevant: they already define structured compliance and lifecycle expectations for software in financial ecosystems.
6. Teach AI organizational memory, not just code syntax
Inner source is not just code reuse—it’s history:
Why something was built
Why something was deprecated
Why a “simple refactor” never happened
Why two seemingly identical libraries coexist
Humans absorb this over years. AI needs explicit memory scaffolding:
Architecture Decision Records (ADRs)
“Why this exists” documentation
Incident-linked provenance (what broke in production before)
Migration narratives
Without this layer, AI will repeatedly rediscover old mistakes, at machine speed.
7. Optimize repositories for retrieval, not just build
Most repos are optimized for:
CI/CD
Compilation
Developer onboarding
Very few are optimized for:
Semantic search
Chunked retrieval
Contextual embedding
Agent navigation
To improve AI consumption:
Flatten overly nested abstractions where possible
Add explicit “entry points” for understanding a system
Provide curated “golden paths” (how 80% of users should build things)
Reduce ambiguity in naming (AI is extremely sensitive to naming drift)
This is where platforms like GitHub are increasingly important, because code search and semantic indexing become the primary interface—not folder browsing.
8. Design for “collaborative AI contribution loops”
The end state is not AI reading inner source. It is AI participating in it.
That requires:
PR generation with rationale explanations
Automated alignment to repo conventions
Feedback loops from reviewers back into agent memory
Continuous refinement of “what good looks like” per repo
Over time, the system becomes self-calibrating: inner source defines AI behavior, and AI behavior reshapes inner source norms.
Closing thought
Inner source was originally about scaling human collaboration across silos. AI changes the equation: now we are scaling machine collaboration with human-designed ecosystems.
The organizations that succeed won’t just “use AI on their codebases.” They will redesign inner source so that it is legible, navigable, and governable by agents: with as much care as we once applied to human developers.
Because in the near future, the most important contributor to your inner source ecosystem might not be a team at all—but an agent that never sleeps, never forgets, and only understands what you made explicit enough to be understood.
I’m #humbledandhonored to share that I have been appointed to the .NET Foundation Board of Directors – Thank You for your service, Kendall Miller!
The .NET ecosystem has played a significant role throughout my career – as a developer (of it and with it), architect, open source contributor, community organizer, speaker, mentor, and Microsoft MVP. Being entrusted with helping guide the future of this community is both humbling and exciting.
Thank you to everyone who voted, supported my candidacy, encouraged me to run, and contributed to the conversations along the way. Most importantly, thank you to the countless maintainers, contributors, volunteers, sponsors, and community members who make the .NET ecosystem thrive every day.
I look forward to working alongside my fellow board members and the broader community to help the Foundation continue to grow, support its projects, and create opportunities for the next generation of developers.
Here’s to the future of .NET and open source. Looking forward to be working with the new members, Meagon Hansen and Hayden Barnes, and congrats Mitchel Sellers on his re-election to the board! Louëlla Creemers, Chris Woody Woodruff – thank you for your service! Chris Sfanos, Kevin Griffin, Jonathan “J.” Tower, Irina Dominte Scurtu, thank you for the trust in me, looking forward for collab!
One of the most interesting things about looking at this collection of sessions together is that they are not isolated conversations.
They form a trajectory – let me show how. Each session approaches a different part of the modern enterprise technology landscape: AI adoption, agentic development, data quality, governance, observability, user experience, and the evolution of integration itself. But taken together, they describe a broader shift in how we design, build, and operate technology – starting from the keynote and going through each aspect.
The common theme is not simply that AI is changing software.
It is that the enterprise technology stack is becoming more intelligent, more automated, and more connected, and that this makes judgment, governance, trust, and architectural discipline more important than ever.
So, let’s go session by session here! But first, came breakfast!
1. Faster Is Not Always Better: Stop Optimizing the Obvious
The opening keynote by Peter Ward challenged one of the most common assumptions in technology: that faster, more automated, and more AI-driven always means better outcomes.
Peter Ward opening Keynote “The hidden value of asking better questions with AI projects”
While modern cloud platforms and AI capabilities have made it possible to optimize nearly every process, the session argued that judgment—not technology—remains the true differentiator.
Using examples from Copilot deployments, automation initiatives, and digital transformation programs, the presentation demonstrated how organizations often optimize the wrong metrics, achieving technical success while missing the commercial value they were trying to create.
The message was simple: the wrong metric scales just as efficiently as the right one.
The audience was encouraged to shift from measuring activity to measuring outcomes, and to use the Microsoft ecosystem not simply to do things faster, but to make better decisions.
Optimizing the obvious is easy. Optimizing for real business impact is what creates lasting value.
His keynote made serious ripples across the other presenters too – I think there weren’t a single presenter who hasn’t reverted back to Peter’s slides and message.
2. AI-Native Development and Spec Driven Development: Moving Beyond Vibe Coding
That same principle applies directly to software development – as we learned from Dr Dave Goad GAICD in the second session. He explored how the rapid adoption of Agentic AI IDEs has made vibe coding increasingly common, while highlighting why many enterprises have struggled to realize the expected return on their AI investments.
Generating more code faster is not enough.
Dr Dave Goad presenting about the move from vibe coding to spec driven development
Without structure, context, and governance, AI-assisted development can create inconsistent implementations, security concerns, and technical debt at a speed that traditional development processes were never designed to manage.
The presentation introduced Spec Driven Development as the next evolution of AI-native software engineering.
It demonstrated how well-defined specifications can provide the structure and context AI agents need to produce reliable, maintainable, and secure code. Rather than replacing engineering discipline, AI makes that discipline even more valuable.
Attendees learned how organizations can move beyond ad hoc vibe coding toward a scalable enterprise model: one where agents accelerate delivery, but specifications, standards, and human judgment continue to guide the outcome.
We had a greatly appreciated coffee break here with breakfast burritos and more.
3. Toolkit for Building Agents: Microsoft 365 Copilot, Copilot Studio, and SharePoint in Action
The next session, presented by Manpreet Singh, moved from the development lifecycle into the workplace, showing how organizations can begin building practical agents today.
Manpreet Singh speaking about “Toolkit for building Agents: M365 Copilot, Studio & SharePoint in Action”
This hands-on workshop demonstrated how Microsoft 365 Copilot, Copilot Studio, and SharePoint can be used together to create intelligent, low-code agents capable of answering questions, generating content, and automating everyday business processes.
Participants learned how to design, build, and deploy custom agents tailored to their organizations’ needs, while using SharePoint as a secure, context-rich knowledge source.
Through practical exercises and guided demonstrations, the session explored when and where each tool fits, how low-code conversational agents can be created in Copilot Studio, how Microsoft 365 Copilot can be extended with custom capabilities, and how AI experiences can be integrated into SharePoint. The workshop also covered licensing considerations, implementation patterns, tips, and best practices.
The key takeaway was that agents are most valuable when they are not treated as isolated experiments. You see how this fits into the general message? They become useful when they are connected to organizational knowledge, embedded into existing workflows, and governed in a way that keeps humans in control.
4. Embedding Governance into the SDLC: Enforcing Backlog Integrity Through Pull Request Checks
Did you know your backlog is lying? Do you even still maintain one? Our beliefs been shattered in the session from Vladimir Gusarov (and saw the open source 3D printable octocat lamp live!). Why? As AI increases the speed of delivery, it also increases the importance of quality at the source.
Vladimir Gusarov presenting about “Your Backlog Is Lying: Enforce It with PR Checks”
His presentation demonstrated why maintaining a consistent and well-structured backlog is essential for producing reliable metrics, accurate planning, and effective software delivery.
If your backlog is not consistent, your metrics and plans are not either. The presentation showed how organizations can embed governance directly into the development workflow by using Pull Request validation in Azure Repos and GitHub. Attendees learned how to validate linked work items, enforce required fields and naming conventions, and automatically block pull requests that fail to meet organizational standards.
Rather than introducing manual reviews or additional bureaucracy, the approach placed guardrails directly inside the tools developers already use. The session also showcased repeatable implementation patterns, including PR checks, validation rules, and integrations between Azure Boards, Azure Repos, and GitHub.
The broader lesson was important: governance works best when it is not added after the fact. It should be built into the workflow.
5. From UDDI to MCP: History Is Repeating, but This Time It Might Work
The sixth session – by me – stepped back and looked at the historical arc behind many of these developments.
I am speaking about “From UDDI to MCP – What We Learned About Finding APIs in 30 Years?”
I explored how today’s AI agent ecosystem has brought the industry full circle, tracing the evolution from UDDI and Microsoft Hailstorm to Model Context Protocol, agent skills, and modern AI collaboration.
Rather than presenting MCP as an entirely new idea, I demonstrated how many of today’s concepts are the natural evolution of ambitions first imagined more than two decades ago.
The industry has long wanted systems that could discover capabilities, understand contracts, connect services, and act on behalf of users.
What has changed is the environment. Cloud platforms are mature. Identity systems are stronger. Semantic search is practical. Large language models can interpret intent. Agents can reason across tools. Protocols such as MCP can help expose capabilities in a consistent way.
My session contrasted contracts with intent, integration with collaboration, and static registries with intelligent, discoverable capabilities. It also explored the questions that remain: governance, trust, security, interoperability, and standardization. The technology has changed dramatically. The original vision has not. This time, the ecosystem may finally be ready to realize it. Recognizing this was helped by another coffee break.
Yummie!
6. Building an Enterprise ChatGPT-Style Application with Azure OpenAI and RAG
The next session, from David Patrick, focused on one of the most common enterprise AI use cases: grounding conversational AI in private organizational knowledge.
David Patrick speaking about “From Zero to ChatGPT: Building Your Own AI Assistant with Azure AI”
The presentation demonstrated how to build and deploy an enterprise-grade, ChatGPT-style application using Python, Azure OpenAI Service, and Azure AI Search with Retrieval Augmented Generation.
Using practical examples based on employee handbooks, benefits guides, and role descriptions, the session showed how to ingest, chunk, embed, index, and retrieve information from internal PDF documents.
Participants learned how to wire these capabilities into a conversational interface capable of answering questions using private organizational data rather than relying solely on public internet knowledge.
The session walked through the full architecture, explained the role of each Azure service, and shared reusable Python implementation patterns for building secure and scalable chat experiences.
This connected naturally with the earlier discussion about agents (you see the trend?).
An enterprise chatbot is not simply a better search box. It is an example of a broader architectural pattern: AI becomes valuable when it is grounded in trusted data, connected to organizational context, and deployed with security and governance in mind.
7. From Data Democratization to Data Enablement
That same story applies to data (long live the data scientists!).
Preeti Gupta speaking about “Data Enablement in Regulated Finance: Moving Beyond Access to Outcomes”
Over the past few years, many organizations have invested heavily in making data more accessible. But wider access has not always translated into better decisions, faster delivery, or measurable outcomes.
The problem is not access. It is what comes after. The seventh session, from Preeti Gupta , challenged the assumption that data democratization alone creates value.
Drawing on experience from regulated enterprise environments, the presentation showed why organizations often struggle to turn available data into actionable insight. Without clear ownership, consistent quality, and embedded governance, access can scale confusion instead of value.
The session introduced data enablement as the next stage in the evolution of enterprise data strategy. Attendees explored how organizations can move from datasets to data products, assign clear ownership and accountability, adopt platform thinking, and provide reusable self-service capabilities. The presentation also emphasized the importance of embedding governance and compliance directly into workflows, using guardrails rather than relying entirely on manual controls.
Open-source principles were positioned as an important foundation for building interoperable, scalable, and sustainable data platforms. This connected directly to the earlier RAG and agent sessions. AI systems are only as useful as the information they can trust. Data enablement is not a separate concern from AI adoption. It is one of its most important prerequisites.
8. Observability Deep Dive: Correlating Logs Across Azure Monitor, Application Insights, and Distributed Services
As applications become more distributed and intelligent, operational visibility becomes equally important.
The eighth session, from Monika Mundra , (PMP) , took a deep dive into observability in Azure, demonstrating how to correlate logs, traces, dependencies, and telemetry across Azure Monitor, Application Insights, and distributed services.
Monika Mundra presenting about “Observability Deep Dive: Correlating logs across azure monitor, app insights and distributed service”
Through practical examples, attendees learned how telemetry flows across modern cloud-native applications and why correlation is essential for understanding complex request paths.
The presentation showed how to write Kusto Query Language queries to trace requests end-to-end, identify bottlenecks, and diagnose failures across multiple services. Participants also explored correlation strategies they could implement in their own applications to improve visibility, reduce mean time to resolution, and simplify debugging in distributed environments.
This session reinforced a recurring theme across all of them:
Complexity should not be managed through additional manual effort. It should be managed through better platforms, stronger instrumentation, embedded standards, and reusable patterns. Observability is not an operational afterthought. It is part of the architecture.
And this session also came with the lunch!
9. Agent-Driven UI Development with MCP Servers, Skills, and Ignite UI
The sponsorship session brought the discussion back to the developer experience and showed what agent-driven workflows can look like in practice – thank you for Jason Beres for the engaging examples and real-time demos, you were brave on that Wi-Fi!
Jason Beres speaking about “Building Enterprise Apps with AI, MCP and Components”
Modern UI development is moving beyond AI-assisted code completion toward agents that understand frameworks, component libraries, and design systems. The presentation explored how MCP servers and Skills can accelerate the development of .NET applications and modern web interfaces across Blazor, Angular, and React.
Skills were presented as the “brain” of the workflow. They provide framework-aware guidance for correct component usage, imports, patterns, project conventions, naming rules, and theming standards. MCP servers were presented as the “hands.” They allow agents to scaffold UI, query component APIs, generate design-token-aware themes, and apply complex styling without inventing brittle CSS.
Using Ignite UI as a practical example, the session demonstrated how Skills and MCP servers can work together to generate grounded, on-brand, runnable code across Angular, React, Blazor, and Web Components. Attendees also learned how to adapt Skills for their own teams, encode preferred patterns, and handle advanced theming scenarios such as palette generation, adaptive contrast, typography, spacing, border radius, component-level styling, and design-system switching across Material, Fluent, Bootstrap, and Indigo.
The session closed with a practical model for AI-ready UI development:
Use Skills to reduce hallucinations. Use MCP servers to execute real development tasks. Use trusted component libraries and design systems to keep applications consistent, maintainable, accessible, and visually aligned.
10. Where do Copilot Studio Finishes and Where does AI Foundry Starts?
Last session of the day was from Abhijeet Jadhav (PMP®) – he explored how organizations can recognize when an AI solution has outgrown the capabilities of Microsoft Copilot Studio and when it is time to consider a move toward Azure AI Foundry.
Abhijeet Jadhav presenting about “Copilot Studio to Azure AI Foundry: A Framework for Knowing When – and How – to Scale”
Rather than presenting the platforms as competing choices, the discussion framed them as different stages in the maturity of an enterprise AI implementation, each suited to a particular level of complexity, scale, and customization.
The presentation introduced a practical framework for identifying the tipping point between low-code agent development and more advanced AI engineering. Attendees learned how to evaluate factors such as integration complexity, extensibility requirements, governance, performance, data orchestration, and the need for more sophisticated model management. The session also provided guidance on how to plan the transition across platforms without losing the speed and accessibility that made the initial solution successful. By the end of the presentation, participants had gained a clearer understanding of how to scale AI implementations deliberately, using Copilot Studio where it adds the most value and moving to Azure AI Foundry when enterprise requirements demand greater control, flexibility, and architectural depth.
One Trajectory: From Automation to Intelligent Enterprise Platforms
Taken together, these sessions describe a single evolution. We are moving from automation to intelligent systems. From AI-assisted development to agent-driven workflows. From ad hoc vibe coding to Spec Driven Development. From isolated copilots to grounded enterprise agents. From static integrations to discoverable capabilities exposed through MCP. From data access to trusted data products. From manual governance to embedded guardrails. From reactive troubleshooting to end-to-end observability. From generated UI code to framework-aware, design-system-aware development agents. From citizen developers to AI enabled power users.
The thread connecting all of them is that enterprise AI cannot simply be layered on top of existing complexity. It has to be woven into the architecture. The organizations that succeed will not necessarily be the ones that deploy the most copilots, generate the most code, or automate the largest number of workflows.
They will be the ones that combine speed with judgment. AI with trusted data. Autonomy with governance. Developer productivity with engineering discipline. Innovation with observability.
And intelligent agents with platforms designed to make them safe, useful, and scalable. That is where the real value is. And that is the trajectory these sessions collectively explored.
Again, would like to thank to our sponsors, Infragistics and Microsoft – and see you on November 16th for the #MSIgniteNYC conference! And congratulations for Brian Stith for winning the Quest headset of the raffle!
Many people at apidays asked whether my presentation was recorded. I am not sure they were, but, till I figure that out, let me share my slide deck, and also use this opportunity to use to advertise some of the events I advertise on the last slide – next week’s hybrid FSI Autism Hackathon and Microsoft Build //localhost:newyork, an in person Microsoft conference in New York on June 9th.
There was a time when the ultimate brag in tech sounded something like this:
“I pulled an all-nighter debugging a race condition in production.”
or
“I can still write LINQ from memory without IntelliSense.”
or, for the truly elite:
“I use Vim, by choice.”
But times change.
Now, somewhere between the rise of executive engineering, the cult of endless meetings, and the great migration from builders to “strategic enablers,” a new flex has emerged in IT circles:
“I haven’t opened an IDE in 14 months.”
And people say it… proudly.
Not with shame. Not as a confession. As a badge of honor.
Like they’ve ascended.
Like Visual Studio, Visual Studio JetBrains Rider, JetBrains Rider or IntelliJ IDEA IntelliJ IDEA are now beneath them.
As if syntax highlighting is for peasants.
As if stepping through code with a debugger is a quaint hobby from their youth, like collecting Pokémon cards or believing sprint retrospectives improve culture.
Apparently, true seniority is now measured not by what you can build, but by how long it has been since you’ve actually built anything.
The Promotion Ladder to IDE Abstinence
The career progression seems clear:
Junior Engineer:
“Why is this null?”
Mid-Level Engineer:
“I fixed the null.”
Senior Engineer:
“I designed a pattern so nulls can never happen.”
Staff Engineer:
“I reviewed the architecture for null prevention.”
Principal Engineer:
“I align cross-functional stakeholders around null strategy.”
VP of Engineering:
“I haven’t seen code since the Kennedy administration.”
And somewhere in there, opening an IDE becomes suspicious.
“Oh, you still code?”
The same tone people use when they ask if you still use cash.
Calendar-Driven Development
Modern leadership has introduced a new programming language: Outlook
Its syntax is mostly:
“Circling back”
“Quick sync”
“Let’s double-click on that”
“Can we take this offline?”
“Per my last email”
Its runtime environment is a 47-tab browser and existential dread.
Its compiler is a quarterly business review.
Its debugger is your therapist.
And instead of breakpoints, we now have “alignment sessions.”
You no longer solve problems.
You facilitate their visibility.
The Quiet Tragedy of Losing Touch
Here’s the uncomfortable truth:
There is a difference between leading engineers and forgetting how engineering feels.
When you stop touching code entirely, something subtle starts to disappear.
You lose the friction.
You forget how long “just a small change” actually takes.
You stop remembering that renaming one innocent-looking field can trigger the digital equivalent of a small civil war.
You begin to say dangerous things like:
“Can’t we just…”
No sentence in software history has caused more suffering than:
“Can’t we just…”
Can’t we just move it to the cloud? Can’t we just add AI? Can’t we just rewrite it in Rust? Rust Can’t we just make it real-time?
No. We cannot “just.”
We can barely “eventually.”
IDEs Were Never Just Tools
A proper IDE was never just software.
It was a cockpit.
It was a workshop.
It was where thinking happened.
Visual Studio wasn’t just an application—it was a place where arguments with the compiler made you a better person.
Debugging taught humility.
Refactoring taught discipline.
Watching your build fail because of one missing semicolon taught character.
And yes, Git taught trust issues.
The IDE was where craftsmanship lived.
Not the PowerPoint.
Not the roadmap.
Not the strategy offsite with artisanal sparkling water.
The IDE.
AI Is Making This Worse (and Funnier)
Now, with copilots everywhere, people have found a new justification.
“I don’t need to code. I architect prompts.”
Ah yes.
From software engineer to prompt sommelier.
“Hmm yes, this deployment issue has strong notes of context window collapse and a surprisingly bold hallucination finish.”
There is real value in AI-assisted development, of course.
But outsourcing your entire relationship with code is like becoming a restaurant critic because you once microwaved pasta.
Useful perspective? Maybe.
Chef? No.
The Best Leaders Still Open the Hood
The strongest technical leaders I know still occasionally open the IDE.
Not because they need to ship every feature.
But because they refuse to become tourists in their own domain.
They prototype.
They test assumptions.
They verify.
They stay close enough to reality that their strategy still fits the terrain.
Because authority without proximity becomes theater.
And engineering has enough theater already.
Final Thought
If your proudest professional achievement is the number of months since you last touched an IDE, congratulations:
You may have successfully escaped the very thing that made you valuable in the first place.
Leadership matters.
Strategy matters.
Scale matters.
But somewhere, hidden beneath twelve recurring meetings and three steering committees, there should still be a person who remembers how to hit F5 and mean it.
Because the day you stop understanding the work is the day your title starts doing all the talking.
A long time ago, in a galaxy not so far away… it became clear that some things travel faster than hyperspace.
“May the Fourth” isn’t just about lightsabers, starfighters, or debating whether Han shot first. It’s about hope when the odds look impossible. It’s about rebellion against bad architecture, legacy systems of oppression, and the occasional Death Star-sized production outage.
It’s about believing that even the smallest droid, the quietest engineer, or the most underestimated padawan can change the course of the galaxy.
The Jedi taught discipline. The Rebels taught courage. The Mandalorians taught branding. And somehow, every enterprise architect still ends up sounding a little like Yoda: “Refactor, or refactor not. There is no try.”
So today, whether you are debugging in the Outer Rim, leading your own Rebel Alliance standup, or simply trying to survive another Monday from the dark side of the calendar…
Trust the Force. Challenge the Empire. And remember: the best pilots, leaders, and developers are often found in the most unlikely places.
Every year, this process is more than a form: it is a moment of reflection.
It makes you pause and ask: 👉 How are you creating impact? 👉 Who are you helping grow? 👉 What are you building that lasts beyond your own work?
For me, the answer has always been about community.
Bridging worlds that do not always naturally connect, enterprise engineering, open source, academia, startups, and local developer communities: and turning those connections into action.
From leading initiatives through FINOS and The Linux Foundation, to organizing Microsoft Build Watch Parties, AI Tour workshops, Ignite community events, the FSI Autism Hackathon, mentoring Imagine Cup teams, and helping engineers turn ideas into patents and real solutions, the goal stays the same:
Create spaces where people can learn, contribute, and build something bigger together.
⚙️ Technology matters. 🧑💻 But people matter more.
The MVP program has always been both a platform and a responsibility, helping amplify ideas, bring community feedback closer to product teams, and ensure innovation stays practical, inclusive, and responsible.
Grateful for every mentor, collaborator, speaker, organizer, and community member who makes this journey meaningful.
A few weeks ago I was lucky enough to get invited to present at the NY Marquis hotel, same that hosted FINOS events before. I was there with the FINOS crew (Gabriele Columbro and Karl Moll), and my topic was – Securing MCPs at Scale, with learning from Microsoft.
There are talks where you present.
And there are talks where something clicks.
This one was the latter.
The Setup: Why MCP Changes Everything
We started with a simple but uncomfortable truth:
MCP doesn’t just connect systems — it expands what AI can do.
And with that expansion comes a shift:
From APIs → capabilities
From requests → actions
From users → agents acting on behalf of users
That’s not evolution. That’s a category change.
And category changes break old security models.
The Problem: When AI Becomes the Attack Surface
The audience immediately leaned in when we reframed the risk:
👉 Traditional security protects endpoints
👉 MCP requires protecting interactions
We walked through the real issues:
Over-privileged tools
Prompt injection as a new attack vector
Agents chaining actions in ways we didn’t explicitly design
Trust being assumed… instead of enforced
The key realization?
The system is no longer what you built. It’s what the agent can compose.
The Turning Point: Principles That Actually Work
This is where things shifted from concern → clarity.
We introduced a simple, memorable playbook:
🔑 Least Privilege
Shrink access. Always.
🪪 Identity & Auth
Short-lived tokens. Strong validation.
🔒 Containment
Isolate tools. Sandbox execution.
⚠�� Treat Prompts as Untrusted
Yes — even your own prompts.
📊 Observability by Design
If you can’t see it, you can’t secure it.
You could feel the room align around this.
Not theory. Not hype. Actionable principles.
The Architecture: Making It Real
Then we grounded it.
We showed what a secure MCP system actually looks like:
Client / Host
MCP Gateway (policy enforcement layer)
Isolated MCP Servers
Identity & Authorization layer
AI Runtime + Tools
And the key insight landed:
Security is not a layer anymore. It’s the glue between every layer.
The Reality Check: Why This Is Hard
This part got nods across the room.
Because everyone has felt it:
AI systems evolve faster than governance
Tool ecosystems grow faster than controls
Trust models lag behind capability models
And the hardest truth:
We are building systems that can act… faster than we can reason about them.
The Answer: Shared Ownership
One of the strongest moments in the session was this shift:
Security is not “someone else’s problem.”
It’s a team sport:
Platform teams → guardrails, gateways, scaling
Application teams → permissions, tool design, testing
Security teams → policy, validation, monitoring
And the takeaway:
If any one of these is missing, your MCP system is already vulnerable.
The Future: Where This Is Going
We closed with what’s coming next — and this resonated hard:
MCP-native Zero Trust agents
Policy-as-Code for AI behavior
Runtime enforcement (AI firewalls are coming)
Capability attestation (prove before you act)
This isn’t optional evolution.
This is where the industry is heading.
The Final Message
We ended with one line that stuck:
“Secure the conversation, not just the connection.”
Because that’s the real shift.
Why This Talk Worked
Looking back, what made this session successful wasn’t just the content.
