Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
149794 stories
·
33 followers

BONUS Guardrails Over Processes—How to Scale Teams Without Killing Creativity With Prashanth Tondapu

1 Share

BONUS: Guardrails Over Processes—How to Scale Teams Without Killing Creativity

What actually slows down tech teams—lack of talent, or lack of ownership? In this episode, Prashanth Tondapu shares lessons from leading through global-scale failures, scaling from a small team to a 100-person company, and discovering why guardrails beat rigid processes when it comes to building teams that own outcomes and execute with discipline.

Diffusion of Accountability: When Everyone Is Responsible, Nobody Is

"Crisis is not the problem. Crisis is the one that uncovers the problem that has always existed."

 

Early in his career, Prashanth witnessed a large-scale failure at a major technology company—not because the team lacked talent, but because accountability had become diffused. When too many people are responsible for something, it translates to nobody being responsible. The team was brilliant individually, but there was no clear demarcation of who owned what outcome. On good days, everything worked. But when things went wrong, there was no single person who could no longer delegate accountability to someone else. In this segment, we also refer to the concept from Extreme Ownership by Jocko Willink.
Prashant argues for: outcome can only come with 100% emotional commitment to a particular problem, and when five people share that commitment, each carries only 20%. That's where breakdowns happen.

The Leadership Design Problem: From Computers to People

"I was a developer who imagined that humans are also going to be as predictable as computers. Until 6 or 7 people, it works well because you can be everywhere. But as soon as we increased above 7, I was not able to be everywhere."

 

Prashanth's journey as a founder mirrors what many tech leaders experience at scale. Starting Innostax at 27 as a developer with no management experience, he initially treated people like predictable systems. Below seven people, it worked—he could be the hero founder, the catch-all. But beyond that threshold, he had to learn delegation, which meant learning to trust. First came the people-dependent phase, then the process-oriented phase with SOPs (Standard Operating Procedures) for everything—even how APIs should look. The SOPs made the team fast at execution, but their clients noticed something troubling: "Your guys do not even ask any questions." The rigid processes had suppressed the very creativity and critical thinking they needed. That feedback became the catalyst for the next evolution: becoming a people-first company.

Guardrails vs. Processes: Freeing Creativity Within Structure

"If something goes wrong, our guardrail is: we will just ask you one question—what was your intent behind doing this?"

 

Prashanth draws a sharp distinction between processes and guardrails. Processes tell you exactly what to do and how to do it—they create predictable execution but kill creativity. Guardrails define the boundaries within which people have freedom to be creative and solve problems their own way. At Innostax, guardrails take practical forms:

 

  • Time-on-task guardrails: If a task takes longer than expected, ask for help—don't rabbit-hole into it for three days

  • Don't be a hero: When friction appears with a client or a problem, escalate early rather than trying to solve everything alone

  • The intent review: When something goes wrong, instead of punishment, they ask three questions—was the intent right, was the approach right, and what was the outcome? If intent and approach were right but it still failed, that's the company's problem, not the individual's

 

This framework creates psychological safety while maintaining accountability. People know they won't be penalized for honest mistakes made with good intent, which means they surface problems early rather than hiding them.

Vision Elements and the People-First Company

"The outcome is not just what is expected, but outcome also consists of what is not expected. People come out in so many creative, great ways that they end up surprising you."

 

The shift to a people-first company meant replacing rigid SOPs with what Prashanth calls "vision elements"—broader directional guidance like "we are working for the client, we need to give the best for the client in the resources that we have." This gives teams a larger sandbox to work in while guardrails prevent them from going too far off course. 

The daily rhythm includes team leads reviewing work summaries—not to micromanage, but to catch misalignment early and offer support. Prashanth emphasizes that guardrails must be created with emotional intelligence and detachment. If you create guardrails assuming you're also part of the problem, they'll be biased and ineffective. That's why he considers emotional intelligence the prerequisite skill for any leader designing team structures.

The Books That Changed Everything

"Whenever I was reading through the fixed mindset guy, it was like it was describing me. And that actually changed everything."

 

Prashanth recommends two foundational books for leaders building ownership-driven teams. First, Mindset by Carol Dweck—a book that cracked his own fixed mindset as a confident developer who thought he knew everything. Reading about the fixed mindset felt like reading his own biography, and that uncomfortable recognition opened him to listening more, seeking exposure to experts, and believing there were perspectives he hadn't encountered yet. Second, Emotional Intelligence by Daniel Goleman—because without mastering emotional intelligence, everything you hear feels personal, clouding your judgment and making you too close to the problem to design effective solutions for your team.

 

Self-reflection Question: Are you building guardrails that give your team freedom to be creative within clear boundaries, or are you still writing processes that tell people exactly what to do—and in the process, suppressing the very thinking you hired them for?

 

About Prashanth Tondapu

Prashanth Tondapu is Founder and CEO of Innostax and a veteran technology leader. He's led teams through high-stakes global incidents at McAfee and scaled disciplined delivery organizations worldwide. His work focuses on ownership, accountability, and designing teams for predictable, sustainable execution as complexity grows.

 

You can link with Prashanth Tondapu on LinkedIn.





Download audio: https://traffic.libsyn.com/secure/scrummastertoolbox/20260317_Prashanth_Tondapu_Tue.mp3?dest-id=246429
Read the whole story
alvinashcraft
just a second ago
reply
Pennsylvania, USA
Share this story
Delete

e242 – Is Your Content a Presentation or a Document?

1 Share

Show Notes – Episode #242

In the world of business communication, the line between a presentation and a document is often blurred—especially when PowerPoint is the authoring tool of choice. In episode 242, our three industry experts—Troy Chollar (TLC Creative Services), Sandy Johnson (Presentation Wiz), and Nolan Haims (Nolan Haims Creative) dive into how they view the differences – between presentation slide, and content document. Their conversation is packed with insights, technical tips, and real-world examples for anyone who creates and delivers presentations – or business documents.

Highlights

  • Distinction between presentations and documents in design and purpose.
  • Content density and design approaches for presentations vs documents.
  • Tools and software updates relevant to presentation design.
  • Importance of understanding client needs and the audience when creating content.
  • Technical considerations in using PowerPoint for both presentations and documents.
  • The role of AI in enhancing presentation workflows and summarization.
  • Best practices for delivering effective client deliverables in different formats.
  • Personal anecdotes and experiences related to presentation design challenges.

Resources from this Episode:  

Show Suggestions? Questions for your Hosts?

Email us at: info@thepresentationpodcast.com

New Episodes 1st and 3rd Tuesday Every Month

Thanks for joining us!

The post e242 – Is Your Content a Presentation or a Document? appeared first on The Presentation Podcast.

Read the whole story
alvinashcraft
11 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

Overview of Entra Workload Identities

1 Share
From: ITOpsTalk
Duration: 3:24
Views: 54

Microsoft Entra workload identities are used by applications, services, automation, and other software workloads to authenticate and access protected resources. In Entra, they typically include app registrations, service principals, and managed identities, and they let workloads get tokens for resources such as Azure, Microsoft Graph, and Microsoft 365 without using a user account. This allows you to give software its own identity with least-privilege access, better governance, and so you can avoid storing long-lived secrets.

Learn about Entra Workload Identities

▶️ https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-overview
▶️ https://learn.microsoft.com/en-us/entra/workload-id/

Content is for educational purposes and is not monetized.

▶️ Script and vocal performance by Orin
▶️ Clockwork Orin Avatar by D-ID
▶️ Voice enhancement by 11labs

Read the whole story
alvinashcraft
17 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

Building Custom LEGO Sets with MCP

1 Share
From: Den Delimarsky
Duration: 27:53
Views: 150

If you ever wanted to leverage AI to help you make use of that forgotten box of LEGO bricks in your closet, well - do I have news for you. There's an open source MCP server that I put together that does just that - AND it will render you the set as you're asking it to change the 100th floating brick.

You can get it on GitHub: https://github.com/dend/brick-mcp-app

You can learn more about building MCP apps here: https://modelcontextprotocol.io/extensions/apps/overview

Music by Oleksandr Stepanov (https://pixabay.com/users/penguinmusic-24940186/) from Pixabay (https://pixabay.com/music/)

Music also by Yurii Semchyshyn (https://pixabay.com/users/coma-media-24399569/) from Pixabay (https://pixabay.com/music/)

#engineering #ai #mcp #tech #lego

Read the whole story
alvinashcraft
26 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

AI Is Amplifying Software Engineering Performance, Says the 2025 DORA Report

1 Share

Artificial intelligence is rapidly reshaping the way software is built, but its impact is more nuanced than many organizations expected. The 2025 DevOps Research and Assessment (DORA) report, titled State of AI-Assisted Software Development, finds that AI does not automatically improve software delivery performance.

By Craig Risi
Read the whole story
alvinashcraft
47 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

WinForms — Generate Custom SVG Skin Palettes with AI (v25.2)

1 Share

In our v25.2 release, we introduced a preview of our AI-powered custom SVG skin palette feature. This feature transforms how you design application color schemes. It leverages generative AI to interpret natural language instructions and create cohesive palettes that apply seamlessly across your entire WinForms application.

Note: We've shared our Generate Custom SVG Skin Palettes with AI implementation with the community to gather feedback and evaluate demand for similar features in DevExpress WPF, Blazor, and JS/DevExtreme product lines.

Generate Custom SVG Skin Palettes with AI - WinForms, DevExpress

How AI-Powered Palette Generation Works

You describe the desired palette aesthetic/style in the conversational UI with plain language. Sample prompts include: "warm autumn palette", "high-contrast accessibility theme", or your favorite sports team name. You then refine results in the chat. The system preserves conversation context for the LLM (the conversation history). AI produces a custom palette and applies it programmatically.

The generated palette includes primary background/foreground colors and accent colors for interactive elements. The palette automatically applies to all DevExpress WinForms UI controls with SVG skin support, which maintains visual consistency throughout the application.

For technical details and extension options, see the Implementation Highlights section.

Real-World Use Cases

This feature addresses common application design scenarios where custom color schemes improve user experience (UX) and business value:

Enterprise Branding - You generate palettes that align with corporate brand guidelines. You describe brand colors and style in plain language. AI creates a palette with consistent color relationships across all UI controls.

High-Contrast and Accessibility Palettes - You design palettes for users with visual impairments. DevExpress WinForms UI Library already includes built-in high-contrast skins and system high-contrast mode support. You specify accessibility requirements (such as tritanopia support). AI generates palettes that meet contrast ratio standards and preserve visual clarity.

Multi-Tenant Applications - You generate a unique visual identity for each customer. You can generate and save palettes per tenant programmatically or allow users to customize their workspace (UI) appearance. This feature also accelerates prototyping. You can generate multiple palette options in minutes and present them to stakeholders.

Seasonal or Event-based Palettes - You refresh application visuals for holidays or campaigns. For example, you can generate palettes for promotions or special events.

Try the Feature with a GitHub Demo

We implemented a complete solution that demonstrates AI-powered SVG palette generation in a Windows Forms application.

Key Features

  • Live palette preview across DevExpress UI controls
  • Instant visual updates during palette generation
  • Compare and switch between AI-generated palettes
  • Persistent palette storage in JSON format within application settings
  • Restore palettes between sessions
  • Palette management with delete support
  • Configurable AI model selection (gpt-5-mini, gpt-4o-mini, gpt-4.1)
  • Support for custom AI services and a rate-limited demo endpoint
  • Customizable AI instructions for tailored generation behavior

Open GitHub Repo

Prerequisites

  • .NET 8+ SDK
  • DevExpress WinForms v25.2+
  • Microsoft.Extensions.AI (v9.7.1)
  • Azure.AI.OpenAI (v2.2.0-beta.5)
  • An active AI service subscription (Azure OpenAI, OpenAI, or Ollama)

Note: The demo targets specific Microsoft.Extensions.AI library versions. Use exact versions to avoid compatibility issues.

Getting Started

  1. Clone the GitHub repo.
  2. Open the solution in Visual Studio or JetBrains Rider.
  3. Configure AI service credentials in ChatClientFactory.cs (or use the rate-limited demo endpoint).
  4. Build and run the DevExpress.AI.WinForms.AIGeneratePalette.Demo project.
  5. Click AI Generate Palette in the Ribbon UI to open the Color Palette Editor.

Use the following prompts to explore the feature:

- Generate a warm autumn palette with rust and gold tones
- Create a high-contrast accessibility-friendly palette for vision impaired users
- Design a modern flat pastel palette inspired by Material Design
- Build a dark mode theme with purple accents
- Make a vibrant tropical palette with coral and turquoise

The workflow completes in seconds. You describe your vision, review the result across controls, refine output with follow-up prompts (if needed), and save the palette. The generated palette is automatically applied to your WinForms application.

Generate Skin Palettes with AI - DevExpress WinForms UI Controls

Ready-to-Use Project

The DevExpress.AI.WinForms.AIGeneratePalette project is production-ready. You can add it to your solution as-is.

The project includes:

  • A palette generation dialog UI
  • AI-powered palette generation logic
  • Palette management and persistence support.

You can customize AI instructions, modify dialog layout, or extend the feature set based on your application requirements.

Under the Hood: Implementation Highlights

The example demonstrates key implementation patterns for AI integration in WinForms applications.

AI Integration and Model Flexibility

The demo application interacts with Azure OpenAI services. It integrates with Microsoft.Extensions.AI library, registers an IChatClient with the AIExtensionsContainerDesktop container, and exposes AI capabilities across the application:

IChatClient chatClient = new Azure.AI.OpenAI.AzureOpenAIClient(
    new Uri(AzureOpenAIEndpoint),
    new System.ClientModel.ApiKeyCredential(AzureOpenAIKey))
    .GetChatClient(ModelId).AsIChatClient();
    
AIExtensionsContainerDesktop.Default.RegisterChatClient(chatClient);

This implementation supports any AI provider that implements IChatClient. You can switch models without code changes. The example supports gpt-5-mini, gpt-4o-mini, and gpt-4.1.

Different LLMs may produce different palette results. We tested AI-powered Color Palette Generation primarily with OpenAI GPT models. You can also connect AI services such as Google Gemini, Anthropic Claude, or xAI Grok. We encourage you to try different models and share your feedback on the ones that work best for your specific needs.

Structured Prompt Engineering

The GeneratePaletteInstruction.md file defines precise AI instructions for palette output. These instructions enforce palette structure and color value rules. Carefully crafted instructions ensure consistent and predictable results across different prompts.

SVG Palette Manipulation

The example creates and modifies SVG palettes. You define palette colors and register the palette in the active skin. The palette becomes available to all SVG-enabled controls at runtime.

var svgPalette = new SvgPalette();
svgPalette.Colors.Add(new SvgColor("Paint", Color.FromArgb(242, 242, 242)));
svgPalette.Colors.Add(new SvgColor("Accent Paint", Color.FromArgb(23, 107, 209)));
// ... additional colors

var commonSkin = CommonSkins.GetSkin(UserLookAndFeel.Default);
commonSkin.CustomSvgPalettes.Add(
    new SvgPaletteKey(commonSkin.CustomSvgPalettes.Count, paletteName), 
    svgPalette);

Conversation State Management

Our implementation maintains the conversation history. Users can refine palettes through follow-up requests. This creates a flexible, interactive workflow in which each adjustment builds on previous decisions and maintains the integrity of the design process.

Palette Persistence and Storage

The example saves and restores custom palettes across application sessions. The AIPaletteRepository class serializes palettes to JSON and stores them in application settings. You can extend this option to any storage solution. For example, store palettes in a database for multi-user scenarios, in configuration files for deployment flexibility, or in cloud storage for cross-device access. The example provides a strong foundation for customization based on your preferences.

Share Your Feedback

This AI-powered palette generation feature is experimental, and we need your feedback to determine our next steps. Based on the response from our community, we will consider similar implementations for WPF (AI-generated resource dictionaries and theme palettes), Blazor (dynamic CSS variable values assignment), and DevExtreme.

We want to understand how this feature fits into development and end-user workflows. Please share your experience with us:


Your feedback will directly shape our future AI-powered roadmap. If you have technical questions or need assistance with the example, submit a support ticket via the DevExpress Support Center.

Additional Resources

Read the whole story
alvinashcraft
54 seconds ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories