--- title: "Microsoft's Prompt Orchestration Markup Language (POML): Structuring the Future of AI Interaction" lang: "en" author: "Mohammad Abu Mattar" canonical: https://mkabumattar.com/post/microsoft-poml-orchestrating-ai-prompts-for-llms --- ![Blog post image for Microsoft's Prompt Orchestration Markup Language (POML): Structuring the Future of AI Interaction - Microsoft's Prompt Orchestration Markup Language (POML) brings structure, semantic tags, and a styling system to prompt engineering for LLMs, with a VS Code extension and Node.js/Python SDKs.](/_astro/hero.ByJZRKLq_1lqge4.webp) [Home](/)›[Blog](/blog)›[All Categories](/blog/categories)›[AI & Machine Learning](/blog/categories/ai--machine-learning) Blog [AI & Machine Learning](/blog/categories/ai--machine-learning)[Developer Tools](/blog/categories/developer-tools)[Software Engineering](/blog/categories/software-engineering) # Microsoft's Prompt Orchestration Markup Language (POML): Structuring the Future of AI Interaction [Mohammad Abu Mattar](/authors/mohammad-abu-mattar)Published: 20 Aug 202523 Mins read42 Mins listen [Markdown for AI(opens in a new tab)](/post/microsoft-poml-orchestrating-ai-prompts-for-llms/index.md "Open the plain-Markdown version of this page, for pasting into an AI tool") TL;DR Microsoft's Prompt Orchestration Markup Language (POML) brings structure, semantic tags, and a styling system to prompt engineering for LLMs, with a VS Code extension and Node.js/Python SDKs. Series [AI & LLM Engineering](/series/ai--llm-engineering)4/5 [PreviousAI is Not Real: A Software Engineering Perspective](/blog/post/ai-is-not-real)[NextGraphRAG Explained: Building Knowledge-Grounded LLM Systems](/blog/post/graphrag-explained-building-knowledge-grounded-llm-systems) All posts in this series (5) Blog5 1. [Understanding Generative AI in Depth](/blog/post/understanding-generative-ai-in-depth) 2. [Building a Code Generative AI Model](/blog/post/building-a-code-generative-ai-model) 3. [AI is Not Real: A Software Engineering Perspective](/blog/post/ai-is-not-real) 4. [Microsoft's Prompt Orchestration Markup Language (POML): Structuring the Future of AI InteractionYou are here](/blog/post/microsoft-poml-orchestrating-ai-prompts-for-llms) 5. [GraphRAG Explained: Building Knowledge-Grounded LLM Systems](/blog/post/graphrag-explained-building-knowledge-grounded-llm-systems) ### Microsoft's Prompt Orchestration Markup Language (POML): Structuring the Future of AI Interaction Contents [Introduction: what is Microsoft's POML and why does it matter for AI?](#introduction-what-is-microsofts-poml-and-why-does-it-matter-for-ai)[How does POML bring structure to prompt engineering?](#how-does-poml-bring-structure-to-prompt-engineering)[Semantic markup: building blocks for clearer prompts](#semantic-markup-building-blocks-for-clearer-prompts)[POML semantic tags and their functions](#poml-semantic-tags-and-their-functions)[Data handling: beyond just text](#data-handling-beyond-just-text)[Decoupled presentation styling: content meets style](#decoupled-presentation-styling-content-meets-style)[Integrated templating engine: dynamic prompt generation](#integrated-templating-engine-dynamic-prompt-generation)[What development tools support POML and simplify the workflow?](#what-development-tools-support-poml-and-simplify-the-workflow)[Visual Studio Code extension: an IDE-like experience for prompt engineering](#visual-studio-code-extension-an-ide-like-experience-for-prompt-engineering)[Cross-platform SDKs: bringing POML into applications](#cross-platform-sdks-bringing-poml-into-applications)[What are the practical benefits and "killer" use cases of POML?](#what-are-the-practical-benefits-and-killer-use-cases-of-poml)[Quantifiable improvements for developers and organizations](#quantifiable-improvements-for-developers-and-organizations)[Real-world applications (the "killer use cases")](#real-world-applications-the-killer-use-cases)[How does POML fit into multi-agent AI workflows?](#how-does-poml-fit-into-multi-agent-ai-workflows)[The growing complexity of multi-agent systems](#the-growing-complexity-of-multi-agent-systems)[POML's role in structuring and orchestrating prompts for collaborative AI agents](#pomls-role-in-structuring-and-orchestrating-prompts-for-collaborative-ai-agents)[What are the technical underpinnings of POML?](#what-are-the-technical-underpinnings-of-poml)[The "view layer" concept: prompt as presentation](#the-view-layer-concept-prompt-as-presentation)[The compilation process: from markup to plain text](#the-compilation-process-from-markup-to-plain-text)[The role of intermediate representation (IR)](#the-role-of-intermediate-representation-ir)[What are the criticisms and community perspectives on POML?](#what-are-the-criticisms-and-community-perspectives-on-poml)[Conclusion: the future of prompt engineering with POML](#conclusion-the-future-of-prompt-engineering-with-poml)[References](#references) ## [Introduction: what is Microsoft’s POML and why does it matter for AI?](#introduction-what-is-microsofts-poml-and-why-does-it-matter-for-ai) Large Language Models, or LLMs, are changing fast, and they’re becoming super important for all sorts of complex applications. Usually, writing good prompts for LLMs, what we call prompt engineering, has felt more like an art than a science. That’s because we’ve mostly relied on just writing free-form text. While that’s fine for simple chats, it gets really tricky when developers try to build complex AI apps. When prompts get bigger and more complicated, they often turn into what developers call “spaghetti code”. It gets messy, hard to fix, and tough to grow. Think about building a huge software system with just plain text files, no programming languages or fancy tools. That’s exactly the kind of problem Microsoft’s Prompt Orchestration Markup Language, or POML, wants to solve for prompt development. This change in how we build prompts is a lot like how software engineering itself grew up. Software used to be low-level and messy, but it got better with high-level languages and smart development tools (IDEs). We learned to make things modular, reusable, and easy to track changes. POML is a big step toward bringing those proven software engineering ideas into prompt engineering. That shift could even mean new job titles, like “Prompt Orchestrator” or “AI Architect.” These folks would design the whole brain of AI systems using structured languages like POML, instead of just writing one-off prompts. So, what is POML? It’s a new markup language from Microsoft, kind of like HTML for websites, but built specifically to make advanced prompt engineering for LLMs more organized, easier to keep up with, and super flexible. It works as a declarative language, meaning you tell an AI orchestrator _what_ to do: how to run prompts, make choices, call APIs, and handle complicated tasks. POML tackles some big problems we’ve seen with traditional prompt development head-on: - **Lack of Structure:** Regular prompts are often just free-form text, which makes them tough to manage and grow. POML brings in a clear structure, and Microsoft’s own tests show it can cut version control headaches by 65%. - **Complex Data Integration:** Dealing with different kinds of data, like mixing text with images or documents, usually means a lot of manual, clunky work. POML introduces special tags (like ``, ``, ``) that let you easily include or link to outside data. This makes your prompts rich with context and information. - **Format Sensitivity:** Even tiny changes in formatting can really mess with what an LLM puts out, making things unpredictable. POML has a styling system, a bit like CSS, that fixes this by keeping your prompt’s content separate from how it looks. This means you can change things like how chatty or formal the AI should be without touching the main instructions. That matters, because LLMs, even with all their smarts, can be surprisingly finicky if you change the input just a little. Separating how your prompt looks from what it actually says addresses that directly. The design does more than make life easier for developers: it puts a layer in front of the model that helps it behave more reliably and predictably. By handling all those little details of LLM input formatting, POML aims to cut down on “LLM output instability” so your AI apps are much more dependable. This focus on reliability shows that POML could help LLM applications move from being cool experiments to solid, production-ready systems where consistent results and less debugging matter a lot. - **Inadequate Tooling and Collaboration Challenges:** Without standard ways to write prompts and good tools, working together on prompts is a nightmare. POML gives you a consistent way to write things and a great set of development tools, including a VS Code extension and SDKs. Early users say it’s boosted their team’s productivity by 30%. ## [How does POML bring structure to prompt engineering?](#how-does-poml-bring-structure-to-prompt-engineering) POML really changes prompt engineering by making it structured and modular, so creating prompts feels a lot more like regular software development. ### [Semantic markup: building blocks for clearer prompts](#semantic-markup-building-blocks-for-clearer-prompts) POML uses a simple, HTML-like way of writing things, with meaningful components that help you build prompts in a modular way. This makes them much easier to read, reuse, and keep updated. These structured tags help developers take big, complicated prompts and break them into smaller, organized, and easier-to-handle pieces. When you see tags like ``, ``, ``, ``, and `` in POML, you can tell what Microsoft is doing. It is putting common prompt engineering “patterns”, telling the AI what role to play, giving it clear tasks, showing it examples, setting output rules, or giving it little nudges, into a formal, structured language. This smart move turns prompt engineering from a random, experimental process into something much more standardized, repeatable, and scalable. It also hints that they understand how LLMs react to structured input, even if the models weren’t specifically trained on POML itself. This standardization could really speed up how we develop and use the best practices in prompt engineering. It’ll make it much simpler for new developers to jump in and help with big AI projects, ultimately building a more mature development world. Here are some of the main semantic tags you’ll find in POML: - **``:** This component defines the persona or specific role the LLM should adopt for a given task. For example, a prompt might begin with `You are a patient teacher explaining concepts to a 10-year-old.`. - **``:** This tag outlines the specific instruction or objective that the LLM needs to perform. An example could be `Explain the concept of photosynthesis using the provided image as a reference.`. - **``:** Key for few-shot prompting, this component provides concrete examples to guide the LLM’s understanding and response generation. It often includes nested `` and `` subcomponents to clearly delineate the example’s structure. - **``:** This tag dictates the desired format and stylistic constraints for the LLM’s response. For instance, it could specify `Keep the explanation simple, engaging, and under 100 words. Start with "Hey there, future scientist!".`. - **``, `
`, ``:** These are specialized data components designed for embedding or referencing external data sources directly within the prompt. - **``:** This tag adds contextual guidance or subtle suggestions to assist the LLM in its response generation. - **``:** A specific tag introduced to cleanly separate a customer’s question from the desired response, effectively turning prompts into support agents. - **``:** This tag is used to define variables within the POML structure, enabling dynamic content. - **``:** This component allows developers to define global or scoped styles for elements, similar to CSS. ### [POML semantic tags and their functions](#poml-semantic-tags-and-their-functions) **Tag** **Purpose** **Example Use Case** `` Defines the LLM’s persona or role. `You are a witty science communicator.` `` Outlines the specific instruction or objective. `Describe how a rocket launches.` `` Provides few-shot examples for guidance. `What is 2+2?4` `` Embeds or references images for context. `Process diagram` `` Embeds or references external text documents. `` `
` Embeds or references tabular data. `
src="sales.csv" />` `` Defines global or scoped presentation styles. `{ "p": { "syntax": "json" } }` `` Defines variables for dynamic content. `Alice` `if (attribute)` Applies conditional logic to elements. `

Admin message.

` `for (attribute)` Iterates over lists to generate dynamic content. `{{item}}` `` Adds contextual guidance for the LLM. `Focus on the key takeaways.` `` Separates a question from its desired response. `What is POML?...` `` Specifies the desired format/style of LLM output. `Provide a detailed explanation.` ### [Data handling: beyond just text](#data-handling-beyond-just-text) POML lets you easily bring all sorts of data right into your prompts, going way beyond just static text. You can embed or link to outside data like text files, spreadsheets, images, Word documents, PDFs, CSVs, and even audio files. This makes your prompts incredibly dynamic and full of context, so they can look more like detailed reports than just simple sentences. Here’s an example that shows how you can include an image for context: poml\_image\_example.poml ``` 12 You are a patient teacher explaining concepts to a 10-year-old.3 Explain the concept of photosynthesis using the provided image as a reference.4 Diagram of photosynthesis5 Keep the explanation simple, engaging, and under 100 words. Start with "Hey there, future scientist!". 6 ``` This example shows how you can embed an image to give the AI visual context. POML has solid support for multimodal prompts, and it can feed LLM interactions with several different kinds of media. ### [Decoupled presentation styling: content meets style](#decoupled-presentation-styling-content-meets-style) Taking a cue from CSS, POML has a styling system that completely separates what your prompt says from how it looks. This separation means you can change things like how chatty, formal, or structured the AI’s response should be, using `` definitions or inline attributes, without touching the main instructions of your prompt. That decoupling is super important for dealing with LLM format sensitivity, and it makes A/B testing different ways of presenting your prompts much easier, so you can get the best results from your LLMs. For example, you could make all captions appear in uppercase just by setting a style rule. Here’s a snippet that shows it: poml\_style\_example.poml ``` 12 Please provide a detailed, step-by-step explanation suitable for adults. 3 ``` This snippet shows how a straightforward `style` attribute can instantly change the expected output’s verbosity and detail level, all without needing any changes to the core instructional content of the prompt. ### [Integrated templating engine: dynamic prompt generation](#integrated-templating-engine-dynamic-prompt-generation) POML comes with a built-in templating engine that supports variables (`{{ }}`), loops (`for`), conditionals (`if`), and defining variables (``). This dynamic system lets you programmatically create complex, data-driven prompts. You can do cool things like tailoring responses based on a user’s permissions or looping through large datasets. This advanced templating really brings prompt engineering much closer to what we do in traditional software programming. Here’s a snippet that shows what POML’s templating engine can do: poml\_template\_example.poml ``` 12 3 4 5 {{ example.input }}6 {{ example.output }}7 8 9 ``` This example iterates through a predefined list of examples (`all_demos`) and dynamically generates captions like “Example 1” and “Example 2” using `loop.index + 1`. This shows how POML can automate the creation of structured few-shot prompts, keeping them consistent and cutting manual effort. ## [What development tools support POML and simplify the workflow?](#what-development-tools-support-poml-and-simplify-the-workflow) Good development tools decide whether a new technology takes off and gets used. POML has a full set of tools that are designed to make prompt engineering much smoother. ### [Visual Studio Code extension: an IDE-like experience for prompt engineering](#visual-studio-code-extension-an-ide-like-experience-for-prompt-engineering) Microsoft’s POML extension for Visual Studio Code is packed with features, and it really makes prompt engineering feel a lot like traditional software development. This is a big deal for getting developers to use it, because it gives them a familiar, efficient place to work with prompts. Microsoft has put a lot of effort into this extension, and it’s more than just a handy tool. Since so many developers already use VS Code, putting POML right into it is a smart move that builds on Microsoft’s existing strengths. It is also a clear effort to “standardize the AI development workflow” and really cement “VS Code, GitHub, and Azure as the go-to ecosystem for building serious AI solutions”. By making everything so connected and integrated, Microsoft is creating an environment that encourages developers to stick with their tools for AI projects. This deep integration of tools really points to Microsoft’s long-term goal: to own and simplify the entire AI development process, from writing the first prompt to deploying and managing it. Here are some of the features you’ll find in the POML Visual Studio Code extension: - **Syntax Highlighting:** It makes different parts of your `.poml` files stand out visually, which really helps you read and understand your code better. - **Context-Aware Auto-completion (IntelliSense):** It gives you smart suggestions for tags and attributes as you type, which can cut down the time you spend looking up syntax by about 50%. - **Hover Documentation:** You can just hover over POML elements to instantly see documentation and info, helping you understand how to use them correctly. - **Real-time Previews:** It shows you what your POML prompts will look like as you write them, so you don’t have to keep testing them with a model. This can cut debugging time by 80%, and it’s a big help for quickly trying out new prompt ideas. - **Inline Diagnostics for Error Checking:** It gives you instant feedback on errors right in your code, pointing out syntax problems, missing fields, or type mismatches. This helps you catch about 40% of errors early on, speeding up debugging. - **Integrated Interactive Testing:** You can even test your prompts right inside VS Code, setting up your preferred model providers (like OpenAI, Azure, or Google), API keys, and endpoint URLs. ### [Cross-platform SDKs: bringing POML into applications](#cross-platform-sdks-bringing-poml-into-applications) To make sure POML works for everyone and fits into different developer worlds, Microsoft has released SDKs for popular languages like Node.js (JavaScript/TypeScript) and Python. These SDKs make it super easy to plug POML prompts into all sorts of applications and existing LLM frameworks. - **Node.js (TypeScript) SDK:** You can easily install this SDK using `npm install pomljs`. It lets developers import POML components (like `Paragraph` and `Image`), parse POML markup into an intermediate representation (IR), and then turn that IR into various output formats, including Markdown. poml\_nodejs\_example.ts ``` 1// Import necessary components and functions from the POML SDK2import { Paragraph, Image } from 'poml/essentials';3import { read, write } from 'poml';4 5// Define a POML prompt using JSX-like syntax6const prompt = 7 Hello, world! Here is an image:8 9;10 11// Parse the prompt components into an intermediate representation (IR)12// This step processes the structured POML into an internal format13const ir = await read(prompt);14 15// Render the IR to different formats, for example, Markdown16// This converts the internal representation into a human-readable string17const markdown = write(ir);18 19// You can then use the 'markdown' string as input for an LLM or display it20console.log(markdown); ``` - **Python SDK:** Developers can install the Python SDK using `pip install --upgrade poml`. This SDK lets you work with POML files and components directly in your Python projects. You can load from files, apply stylesheets, and get outputs in various formats (like OpenAI chat format or Pydantic objects). Plus, it has built-in integrations with popular tools like LangChain, MLflow, and Weave for better logging and templating. poml\_python\_example.py ``` 1# Import the main poml function2from poml import poml3 4# Basic usage: process a markup string with context5# The 'name' variable in the markup will be replaced by 'World'6result = poml("

Hello {{name}}!

", context={"name": "World"})7print(result) # Expected output: {'content': 'Hello World!', 'format': 'text'}8 9# Example of loading from a file and applying a stylesheet (assuming chat.poml exists)10# messages = poml(11# "chat.poml",12# stylesheet={"role": {"captionStyle": "bold"}}, # Apply a custom style13# format="openai_chat" # Get output in OpenAI chat message format14# )15# print(messages) # Expected output: List of OpenAI chat messages ``` The POML community is also growing, with projects like `mini-poml-rs` (an experimental Rust-based renderer) and `poml-ruby` (a Ruby gem implementation). These projects show that there’s wider interest and that POML could be used with even more programming languages and environments. It’s pretty interesting, and a bit odd, that even though Microsoft created POML and .NET is a core Microsoft developer platform, the info we have clearly says there’s “no C#/.NET SDK”. The community has called this “wild” and “Classic Microsoft behavior”. This seems like an oversight or a choice that leaves a big hole in Microsoft’s otherwise complete tool strategy, making .NET developers “Frankenstein together something just to use it in my stack”. This missing piece could really slow down how many .NET developers pick up POML, limiting its overall reach and impact, even with all its other great features. It also makes you wonder about how Microsoft is aligning its internal strategy and allocating resources for new open-source projects. ## [What are the practical benefits and “killer” use cases of POML?](#what-are-the-practical-benefits-and-killer-use-cases-of-poml) POML brings real, measurable improvements for developers and companies. It fixes old problems in prompt engineering and opens the door for new kinds of AI applications. ### [Quantifiable improvements for developers and organizations](#quantifiable-improvements-for-developers-and-organizations) - **Higher Efficiency:** Microsoft’s early internal tests show that developers using POML are over 40% more efficient when they’re building complex prompts. This efficiency comes from POML’s structured approach and strong tools that make creating and managing prompts much simpler. - **Improved Maintainability:** POML really makes prompts easier to maintain, so developers “won’t lose their mind when prompts get long, messy, and reused by 5 different teams across 3 time zones”. Its modular design and clear structure make prompts simpler to understand, update, and manage as time goes on. - **Better Collaboration:** Because it gives you a unified and structured way to write prompts, POML has reportedly boosted team productivity by 30% for early users, making collaborative prompt development much smoother. This standardization means less confusion and easier teamwork. - **Reduced Version Control Conflicts:** POML’s structured approach led to a 65% drop in version control conflicts during Microsoft’s internal tests. That’s a huge plus for teams sharing prompt code. - **Faster Debugging:** The Visual Studio Code extension’s real-time preview shows you your prompts instantly, cutting debugging time by 80%. This instant visual feedback helps developers find and fix problems super fast. - **Early Error Detection:** The VS Code extension’s error diagnostics give you immediate feedback, helping you catch about 40% of early syntax issues, missing fields, or type mismatches. Catching errors this early saves a ton of time and effort later on. - **Simplified Dynamic Prompt Generation:** POML’s built-in templating engine makes creating dynamic prompts a breeze, like tailoring responses based on user permissions or real-time data. That flexibility is what lets an AI system adapt at all. ### [Real-world applications (the “killer use cases”)](#real-world-applications-the-killer-use-cases) The really cool “killer use cases” show that POML is useful for much more than just writing individual prompts. It’s built to help you create complete, strong AI-powered applications. Automating complex reports, running systematic A/B tests, generating instructions that mix media types: those are application-level features, not single prompt tasks. POML’s real value is in helping you build scalable and maintainable AI solutions, closing the gap between just talking to an LLM and doing full-on software engineering. That makes it part of the foundation for building serious AI systems for businesses, making advanced AI easier to get into and manage for regular software development teams. - **Dynamic Content Generation (Automating Reports):** POML is fantastic for areas that need structured reports, like finance or operations. One e-commerce company managed to automate their weekly sales reports, turning a two-day manual job into just 15 minutes. Their POML templates smoothly combined database queries with natural language, giving them consistent, real-time analysis. - **A/B Testing for Prompt Optimization:** POML’s separated styling system makes it much easier to systematically A/B test different versions of your prompts. Duolingo, for instance, said they found optimal prompts 75% faster and increased their test coverage threefold, which directly made users happier. You need something like this to keep improving LLM performance in a live system. - **Multimodal Instruction Generation:** For apps that mix text with different kinds of media, like creating product descriptions with pictures, POML’s `` tag lets you integrate them smoothly. A furniture retailer used this feature to automatically create image captions with a consistent style and structure. Plus, POML supports embedding other file types like PDFs, CSVs, and audio files, making your prompts incredibly rich with data and super versatile. ## [How does POML fit into multi-agent AI workflows?](#how-does-poml-fit-into-multi-agent-ai-workflows) As AI tasks get more complicated, we’re seeing more multi-agent systems pop up. That’s where several specialized AI agents work together to hit a common goal. ### [The growing complexity of multi-agent systems](#the-growing-complexity-of-multi-agent-systems) Regular single-agent systems just can’t handle really complex, multi-part tasks on their own. Getting multiple specialized AI agents, each with their own skills or roles, to work together lets us build more reliable, adaptable systems that can solve problems collaboratively. This way of building things is especially good for tasks that need a lot of parallel work, handling information too big for one model’s memory, and connecting with many complex tools. While multi-agent systems are capable and flexible, they’re known to “burn through tokens fast”, usually using about 15 times more tokens than a simple chat. That means higher running costs. POML’s structured approach, which is built for efficiency and maintainability, can really help by making prompts shorter and cutting out extra info. By giving subagents clear tasks and structured inputs, POML can help agents run more efficiently, which can lower some of those higher token costs. This makes multi-agent systems more affordable, especially for high-value tasks where the better performance is worth the cost. POML could become one of the tools that make complex AI systems financially practical, so the extra value you get from smart multi-agent teamwork is worth the higher computing costs. ### [POML’s role in structuring and orchestrating prompts for collaborative AI agents](#pomls-role-in-structuring-and-orchestrating-prompts-for-collaborative-ai-agents) POML is clearly “built for multi-agent systems”. It gives you a structured and organized way to define how different parts like language models, outside functions, and memory systems talk to each other and work together in a prompt-driven process. This lets developers build AI systems that are scalable, modular, and easy to maintain, going way beyond simple, one-off conversations. It enables dynamic, multi-step thinking across many agents. Semantic Kernel offers a strong framework for agent orchestration, and some sources say its documentation doesn’t directly mention POML’s integration. Other sources clearly state that “Microsoft debuts POML, a new open-source language for orchestrating AI prompts across multi-agent systems”. This means POML “simplifies how developers design and coordinate AI prompts” and “makes AI workflows more structured, scalable, and adaptable,” especially for multi-agent systems. This suggests that POML provides the really important structured prompt definitions needed for agents in a multi-agent system to talk, delegate, and assign tasks effectively. It gives you a standard way to define the “objectives, output formats, guidance on tools and sources” for subagents, which is super important for avoiding duplicate work and keeping tasks clear. POML basically acts as the “instruction set” for autonomous agents, which makes it a core part of building the next wave of complex, collaborative AI systems, even if its direct integration with frameworks like Semantic Kernel isn’t fully detailed everywhere yet. The “view layer” idea built into POML’s architecture is really helpful here, because it makes debugging prompts super smooth, especially when you’re dealing with complex multi-prompt agent workflows. The articles we looked at don’t show direct examples of POML and Semantic Kernel working together, but Semantic Kernel is a lightweight SDK specifically designed to help developers integrate LLMs, orchestrate multiple AI agents, manage complex workflows, and create structured interactions between people and AI. POML’s natural ability to provide structured, maintainable, and templated prompts fits perfectly with Semantic Kernel’s main goal of building strong multi-agent systems. Semantic Kernel supports different ways of orchestrating agents: Concurrent, Sequential, Handoff, and Group Chat. All of them would really benefit from the precise and flexible prompts that POML helps create. ## [What are the technical underpinnings of POML?](#what-are-the-technical-underpinnings-of-poml) If you understand how POML is built, you’ll see how it manages to bring structure, maintainability, and versatility to prompt engineering. ### [The “view layer” concept: prompt as presentation](#the-view-layer-concept-prompt-as-presentation) POML’s design is really based on the “view layer” idea, much like the Model-View-Controller (MVC) architecture you see in traditional frontend development. In this setup, POML clearly defines how the prompt looks, keeping it separate from the actual data and the logic behind it. This separation lets developers focus on how information appears and is styled in the prompt, without having to worry about complicated data integration or tricky formatting details. Someone from Microsoft Research, who helped build POML, explained this vision. They said POML was designed so that “the view layer should take care of the data, the styles and rendering logic, so that the user no longer needs to care how some table needs to be rendered, how to present few-shot examples, how to reformat the whole prompt with another syntax (e.g., from markdown to XML)”. ### [The compilation process: from markup to plain text](#the-compilation-process-from-markup-to-plain-text) POML is a markup language, using tags just like HTML. Developers write their prompts in POML, and then the POML SDK does something really important: it “compiles it into a plain-text prompt” before that flattened output goes to the LLM. You can think of this as turning a structured blueprint into a flat, easy-to-read document that the LLM can directly use. The full POML architecture uses a clever three-step process for rendering, which keeps it flexible and lets it handle mixed content well: 1. **Segmentation Pass:** First, it scans the raw file content and breaks it down into a hierarchical tree of segments. Each piece gets classified as either `META` (for things like settings), `POML` (for markup blocks), or `TEXT` (for plain text). This step mainly finds where the POML blocks start and end, without fully digging into their complex XML structure. 2. **Metadata Processing:** Next, all the `META` segments it found are processed to fill up a global `PomlContext` object, which holds variables and other important context. Once they’re processed, these segments are removed from the tree, since their only job is to set up the context. 3. **Text/POML Dispatching (Recursive Rendering):** This final step involves sending `TEXT` and `POML` segments to their specific readers for rendering. The PureTextReader takes care of `TEXT` segments, rendering their content (maybe using a Markdown processor) and swapping in any variables. The PomlReader handles `POML` segments. Before parsing the XML, it replaces any direct child `` regions with placeholder tags that close themselves (like ``). The original content of these `` segments gets stored separately in `context.texts`. This clever trick makes sure the XML parser inside `PomlFile` doesn’t run into non-XML content and crash. In the end, it creates the final, flattened prompt for the LLM. The way POML gets compiled from its structured form into a plain-text prompt is a really important design choice with big implications. This means the LLM itself doesn’t need to “understand” or interpret POML’s specific tags or how it’s structured. Instead, it just gets a standard, flat text prompt. This intentional design makes POML work with _any_ LLM, no matter if that model was specifically trained on POML syntax or not. That directly answers the common criticism from the community that “LLMs don’t care about formatting unless they were trained to”. So POML’s real value is in structuring the _input generation process_ for developers, rather than changing how the LLM actually processes text. This makes POML much more widely applicable, positioning it as a versatile tool that works with different LLM providers and models, instead of being stuck in just one Microsoft-trained ecosystem. ### [The role of intermediate representation (IR)](#the-role-of-intermediate-representation-ir) While we don’t have all the nitty-gritty details about POML’s Intermediate Representation (IR), the idea of an IR is super important in how compilers work and how programs are analyzed. An IR is like an internal blueprint that represents source code in a way that’s perfect for more processing, optimization, and translation. For POML, after the initial segmentation and parsing, the structured POML content is very likely turned into this kind of IR. This intermediate form would allow for internal logic like templating, swapping out variables, and conditional rendering, all before it’s finally “flattened” into a plain-text prompt for the LLM. The Node.js SDK example actually mentions parsing “prompt components into an intermediate representation (IR)” and then rendering it, which confirms that an IR is a real part of how POML processes things. The fact that they explicitly mention an Intermediate Representation (IR) and that detailed multi-pass processing pipeline really drives home the idea that POML is like a sophisticated “compiler” for prompts. Just like a regular compiler turns high-level code into optimized machine code, using an IR for better performance and portability, POML takes structured, human-readable markup and turns it into an optimized, flat text prompt that LLMs can use. This behind-the-scenes processing is exactly what makes POML’s dynamic templating and separated styling work so smoothly. That technical depth puts POML well past a simple templating engine: it’s a solidly designed system for creating complex prompts, hinting at possible future features like static analysis, advanced debugging, or even prompt optimization at the IR level. ## [What are the criticisms and community perspectives on POML?](#what-are-the-criticisms-and-community-perspectives-on-poml) When POML first came out, it got all sorts of reactions in the tech community, sparking “intriguingly polarized” discussions on places like Reddit and Hacker News. This mixed reception really shows the ongoing debate between keeping things simple and adding structure in the fast-changing world of AI. The main tension in the criticisms, especially the idea that LLMs don’t care about formatting versus POML’s intentional structure, reveals a core paradox in current AI development. LLMs are built to understand natural language, but to get consistent and predictable results in prompt engineering, you often need highly structured, almost programmatic inputs. POML tries to fix this by giving you a human-friendly, structured _writing_ experience, which then gets “flattened” into a plain-text prompt for the LLM. This ongoing debate highlights the constant challenge of designing good interfaces that connect precise human intent (managed and structured by POML) with the nuanced, often less predictable, ways LLMs process things (since they work with natural language). POML’s ultimate success depends on whether its “flattened” output is truly best for LLMs, and more importantly, if the real benefits it gives developers are worth the perceived extra work or complexity. This lively debate shows how prompt engineering is growing up as a field. As the field moves forward, tools like POML will keep getting a close look to see their practical value, efficiency, and overall impact on building real-world AI applications, pushing the limits of how we interact with and control advanced AI. Here are some of the main criticisms and concerns: - **LLMs’ Understanding of Formatting:** A big, repeated criticism is the claim that “LLMs don’t care about formatting unless they were trained to”. Critics say that if an LLM hasn’t been specifically trained to understand and use POML tags, it might just ignore them or, even worse, “choke on them,” leading to unpredictable or bad results. This means POML’s effectiveness might really depend on how LLMs are trained in the future, or if it can consistently turn into a format that all LLMs can reliably understand. - **Added Layer of Abstraction:** Some people feel POML adds an “unnecessary layer of abstraction”. They argue that it turns a simple “text → LLM” interaction into a more complex “text → markup → compile → LLM” pipeline, adding “More moving parts. More failure points,” which can make debugging and managing the whole system harder. Even a Microsoft Research team member admitted to feeling “hopeless about POML” at one point, recognizing that models have evolved so quickly they’re less sensitive to small format changes now. - **“Heavy” and Verbose Syntax:** POML’s syntax has been called “heavy” and like “2005-era websites again,” with “Verbose tags” and “Bracket soup”. This criticism suggests that even though it aims to add structure, the syntax might not always be the easiest or prettiest for developers to read. - **Lack of .NET support:** A particularly hot topic, especially since Microsoft is behind POML, is the obvious lack of a C#/.NET SDK. Some see this as “wild” and “Classic Microsoft behavior”, forcing .NET developers to “Frankenstein together something just to use it in my stack”. - **Structure for Developers, Not LLMs Directly:** A common feeling is that POML mainly offers “structure for devs who are writing prompts in messy workflows,” rather than directly making the LLM smarter. While it definitely helps human developers manage long, complex, and reused prompts, its direct effect on the LLM’s performance or how it understands things is questioned, especially if the model isn’t specifically trained on this format. Critics suggest it might just be “wrapping clean text with noisy tags”. - **“Programming LLMs to Program”:** This higher-level criticism points out the growing layers of abstraction: “The tool that writes prompts is now a program, which builds programs, which generate code”. This view suggests an approach that might be too complicated for what you’re trying to do, raising questions about finding the right balance between abstraction and direct control. ## [Conclusion: the future of prompt engineering with POML](#conclusion-the-future-of-prompt-engineering-with-poml) POML introduces much-needed structure, scalability, and maintainability to prompt engineering. Its modular syntax, data handling, decoupled styling, dynamic templating engine, and integration ecosystem make it a promising standard for orchestrating advanced LLM applications. It pushes prompt engineering from an “art form” toward a “professional, scalable discipline” capable of meeting the demands of enterprise-grade AI solutions. Whether the task involves building complex multi-agent workflows, debugging tangled prompt logic, or developing reusable AI modules for production environments, POML offers a solid, new foundation for developers. POML is Microsoft’s strategic answer to bringing order and scalability to prompt engineering, much the way HTML brought structure to web development. By making POML an open-source project, Microsoft aims to standardize the AI development workflow, positioning Visual Studio Code, GitHub, and Azure as a preferred ecosystem for building enterprise-grade AI solutions. This move aligns with Microsoft’s broader goal: to control and simplify the AI ecosystem, from foundational models and on-device experiences to specialized agents and the tools developers use to build with them. Releasing POML as open source is a deliberate strategic move, not just an act of goodwill. By embracing open-source principles, Microsoft encourages wider adoption, invites community contributions, and positions POML to potentially become an industry standard for prompt orchestration. This strengthens their broader AI ecosystem, spanning Visual Studio Code, Azure, and GitHub, by filling a missing piece for structured LLM application development. This is a classic “embrace, extend, and establish” strategy, aimed at solidifying Microsoft’s leadership and influence in a highly competitive AI market. POML’s ultimate impact will depend on its technical merits and on whether it can build an active, engaged community and integrate cleanly into diverse developer toolchains. ## [References](#references) 1. Prompt Orchestration Markup Language (POML): The Blueprint for the Next AI Revolution, accessed on August 20, 2025, [https://medium.com/@pradipirkar007/prompt-orchestration-markup-language-poml-the-blueprint-for-the-next-ai-revolution-e6c5da1c7a00](https://medium.com/@pradipirkar007/prompt-orchestration-markup-language-poml-the-blueprint-for-the-next-ai-revolution-e6c5da1c7a00) 2. Getting Started - POML Documentation, accessed on August 20, 2025, [https://microsoft.github.io/poml/latest/](https://microsoft.github.io/poml/latest/) 3. POML - Visual Studio Marketplace, accessed on August 20, 2025, [https://marketplace.visualstudio.com/items?itemName=poml-team.poml](https://marketplace.visualstudio.com/items?itemName=poml-team.poml) 4. Microsoft releases Prompt Orchestration Markup Language : r/LocalLLaMA - Reddit, accessed on August 20, 2025, [https://www.reddit.com/r/LocalLLaMA/comments/1mo9vkh/microsoft\_releases\_prompt\_orchestration\_markup/](https://www.reddit.com/r/LocalLLaMA/comments/1mo9vkh/microsoft_releases_prompt_orchestration_markup/) 5. Microsoft Launches POML: Making Prompt Engineering Structured & Developer-Friendly, accessed on August 20, 2025, [https://dev.to/bhuvaneshm\_dev/microsoft-launches-poml-making-prompt-engineering-structured-developer-friendly-4a6h](https://dev.to/bhuvaneshm_dev/microsoft-launches-poml-making-prompt-engineering-structured-developer-friendly-4a6h) 6. Microsoft Releases POML (Prompt Orchestration Markup Language): Bringing Modularity and Scalability to LLM Prompts - MarkTechPost, accessed on August 20, 2025, [https://www.marktechpost.com/2025/08/13/microsoft-releases-poml-prompt-orchestration-markup-language/](https://www.marktechpost.com/2025/08/13/microsoft-releases-poml-prompt-orchestration-markup-language/) 7. Microsoft POML: Can This New AI Markup Language Revolutionize Prompt Engineering? | by AdaGao | Aug, 2025 | Medium, accessed on August 20, 2025, [https://medium.com/@AdaGaoYY/microsoft-poml-can-this-new-ai-markup-language-revolutionize-prompt-engineering-c686ad3adbed](https://medium.com/@AdaGaoYY/microsoft-poml-can-this-new-ai-markup-language-revolutionize-prompt-engineering-c686ad3adbed) 8. Microsoft POML : Programming Language for Prompting | by Mehul Gupta | Data Science in Your Pocket | Aug, 2025 | Medium, accessed on August 20, 2025, [https://medium.com/data-science-in-your-pocket/microsoft-poml-programming-language-for-prompting-adfc846387a4](https://medium.com/data-science-in-your-pocket/microsoft-poml-programming-language-for-prompting-adfc846387a4) 9. Quick Start - POML Documentation, accessed on August 20, 2025, [https://microsoft.github.io/poml/latest/language/quickstart/](https://microsoft.github.io/poml/latest/language/quickstart/) 10. “AI Research Roundup: Meta’s DINOv3, Google’s Nano …, accessed on August 20, 2025, [https://ai.plainenglish.io/ai-research-roundup-metas-dinov3-google-s-nano-bytedance-s-tooltrain-microsoft-s-poml-2bf6eb9a9698?source=rss----78d064101951---4](https://ai.plainenglish.io/ai-research-roundup-metas-dinov3-google-s-nano-bytedance-s-tooltrain-microsoft-s-poml-2bf6eb9a9698?source=rss----78d064101951---4) 11. Visual Studio: IDE and Code Editor for Software Development, accessed on August 20, 2025, [https://visualstudio.microsoft.com/](https://visualstudio.microsoft.com/) 12. Data Handling - GeeksforGeeks, accessed on August 20, 2025, [https://www.geeksforgeeks.org/maths/data-handling/](https://www.geeksforgeeks.org/maths/data-handling/) 13. Microsoft POML Adds HTML-Style Structure to AI Prompts - Petri IT Knowledgebase, accessed on August 20, 2025, [https://petri.com/microsoft-poml-html-style-structure-ai-prompts/](https://petri.com/microsoft-poml-html-style-structure-ai-prompts/) 14. Overview - POML Documentation - Microsoft Open Source, accessed on August 20, 2025, [https://microsoft.github.io/poml/latest/typescript/](https://microsoft.github.io/poml/latest/typescript/) 15. Overview - POML Documentation, accessed on August 20, 2025, [https://microsoft.github.io/poml/latest/python/](https://microsoft.github.io/poml/latest/python/) 16. Semantic Kernel Agent Orchestration | Microsoft Learn, accessed on August 20, 2025, [https://learn.microsoft.com/en-us/semantic-kernel/frameworks/agent/agent-orchestration/](https://learn.microsoft.com/en-us/semantic-kernel/frameworks/agent/agent-orchestration/) 17. Designing Multi‑Agent AI Systems with Semantic Kernel | Amgad …, accessed on August 20, 2025, [https://amgadmadkour.com/blog/2025/semantickernel/](https://amgadmadkour.com/blog/2025/semantickernel/) 18. How we built our multi-agent research system - Anthropic, accessed on August 20, 2025, [https://www.anthropic.com/engineering/built-multi-agent-research-system](https://www.anthropic.com/engineering/built-multi-agent-research-system) 19. Simon Willison on agent-definitions, accessed on August 20, 2025, [https://simonwillison.net/tags/agent-definitions/](https://simonwillison.net/tags/agent-definitions/) 20. POML: Prompt Orchestration Markup Language | Hacker News, accessed on August 20, 2025, [https://news.ycombinator.com/item?id=44853184](https://news.ycombinator.com/item?id=44853184) 21. Extended POML - POML Documentation - Microsoft Open Source, accessed on August 20, 2025, [https://microsoft.github.io/poml/latest/language/proposals/poml\_extended/](https://microsoft.github.io/poml/latest/language/proposals/poml_extended/) 22. Can Large Language Models Understand Intermediate Representations in Compilers?, accessed on August 20, 2025, [https://icml.cc/virtual/2025/poster/43488](https://icml.cc/virtual/2025/poster/43488) Was this useful? ## Tags [#Microsoft](/blog/tags/microsoft)[#POML](/blog/tags/poml)[#Prompt Engineering](/blog/tags/prompt-engineering)[#Large Language Models](/blog/tags/large-language-models)[#AI Development](/blog/tags/ai-development)[#Markup Language](/blog/tags/markup-language)[#Multi Agent Systems](/blog/tags/multi-agent-systems)[#Visual Studio Code](/blog/tags/visual-studio-code)[#Developer Productivity](/blog/tags/developer-productivity)[#AI Orchestration](/blog/tags/ai-orchestration)[#LLM Tools](/blog/tags/llm-tools)[#Software Architecture](/blog/tags/software-architecture) ## Share [Facebook](https://facebook.com/sharer/sharer.php?u=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fmicrosoft-poml-orchestrating-ai-prompts-for-llms "Share on Facebook")[Twitter](https://twitter.com/intent/tweet/?text=Microsoft's%20Prompt%20Orchestration%20Markup%20Language%20\(POML\)%3A%20Structuring%20the%20Future%20of%20AI%20Interaction&url=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fmicrosoft-poml-orchestrating-ai-prompts-for-llms "Share on Twitter")[LinkedIn](https://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fmicrosoft-poml-orchestrating-ai-prompts-for-llms&title=Microsoft's%20Prompt%20Orchestration%20Markup%20Language%20\(POML\)%3A%20Structuring%20the%20Future%20of%20AI%20Interaction&summary=Microsoft's%20Prompt%20Orchestration%20Markup%20Language%20\(POML\)%20brings%20structure%2C%20semantic%20tags%2C%20and%20a%20styling%20system%20to%20prompt%20engineering%20for%20LLMs%2C%20with%20a%20VS%20Code%20extension%20and%20Node.js%2FPython%20SDKs.&source=https://mkabumattar.com "Share on LinkedIn")[WhatsApp](https://wa.me/?text=Microsoft's%20Prompt%20Orchestration%20Markup%20Language%20\(POML\)%3A%20Structuring%20the%20Future%20of%20AI%20Interaction%20https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fmicrosoft-poml-orchestrating-ai-prompts-for-llms "Share on WhatsApp")[Telegram](https://t.me/share/url?url=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fmicrosoft-poml-orchestrating-ai-prompts-for-llms&text=Microsoft's%20Prompt%20Orchestration%20Markup%20Language%20\(POML\)%3A%20Structuring%20the%20Future%20of%20AI%20Interaction "Share on Telegram")[Reddit](https://www.reddit.com/submit?url=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fmicrosoft-poml-orchestrating-ai-prompts-for-llms&title=Microsoft's%20Prompt%20Orchestration%20Markup%20Language%20\(POML\)%3A%20Structuring%20the%20Future%20of%20AI%20Interaction "Share on Reddit")[Hacker News](http://news.ycombinator.com/submitlink?u=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fmicrosoft-poml-orchestrating-ai-prompts-for-llms&t=Microsoft's%20Prompt%20Orchestration%20Markup%20Language%20\(POML\)%3A%20Structuring%20the%20Future%20of%20AI%20Interaction "Share on Hacker News")[Pinterest](https://pinterest.com/pin/create/button/?url=https%3A%2F%2Fmkabumattar.com%2Fblog%2Fpost%2Fmicrosoft-poml-orchestrating-ai-prompts-for-llms&media=&description=Microsoft's%20Prompt%20Orchestration%20Markup%20Language%20\(POML\)%20brings%20structure%2C%20semantic%20tags%2C%20and%20a%20styling%20system%20to%20prompt%20engineering%20for%20LLMs%2C%20with%20a%20VS%20Code%20extension%20and%20Node.js%2FPython%20SDKs. "Share on Pinterest")[Email]() ## Comments ## You might also enjoy More posts on similar topics [![AI is Not Real: A Software Engineering Perspective](/_astro/hero.zLRxEs_v_7tKSA.webp)](/blog/post/ai-is-not-real) ## [AI is Not Real: A Software Engineering Perspective](/blog/post/ai-is-not-real) - [Mohammad Abu Mattar](/authors/mohammad-abu-mattar) - [Artificial Intelligence](/blog/categories/artificial-intelligence) - [Software Engineering](/blog/categories/software-engineering) - [Machine Learning](/blog/categories/machine-learning) - [Technology Ethics](/blog/categories/technology-ethics) We have all seen the wave of hype around artificial intelligence. It is everywhere, from tech conferences to science fiction scripts. As software engineers, though, we need to look past the marketing [#AI Limitations](/blog/tags/ai-limitations)[#Large Language Models](/blog/tags/large-language-models)[#Machine Learning](/blog/tags/machine-learning)+5 tags [read more](/blog/post/ai-is-not-real) [![Understanding Generative AI in Depth](/_astro/hero.DsJ5VDjO_ZYY4n1.webp)](/blog/post/understanding-generative-ai-in-depth) ## [Understanding Generative AI in Depth](/blog/post/understanding-generative-ai-in-depth) - [Mohammad Abu Mattar](/authors/mohammad-abu-mattar) - [Artificial Intelligence](/blog/categories/artificial-intelligence) - [Generative AI](/blog/categories/generative-ai) - [Machine Learning](/blog/categories/machine-learning) - [Deep Learning](/blog/categories/deep-learning) - [Software Engineering](/blog/categories/software-engineering) Introduction Artificial intelligence keeps changing fast, and senior software engineers need to keep up with emerging technologies. One technology that has gotten a lot of attention in recent year [#Generative AI](/blog/tags/generative-ai)[#GenAI](/blog/tags/genai)[#Machine Learning](/blog/tags/machine-learning)+9 tags [read more](/blog/post/understanding-generative-ai-in-depth) [![Building a Code Generative AI Model](/_astro/hero.8WRw1hB0_1Imo6D.webp)](/blog/post/building-a-code-generative-ai-model) ## [Building a Code Generative AI Model](/blog/post/building-a-code-generative-ai-model) - [Mohammad Abu Mattar](/authors/mohammad-abu-mattar) - [Artificial Intelligence](/blog/categories/artificial-intelligence) - [Machine Learning](/blog/categories/machine-learning) - [Software Engineering](/blog/categories/software-engineering) - [Code Generation](/blog/categories/code-generation) - [Python](/blog/categories/python) Introduction Automation is a core part of software engineering. Code Generative AI now makes it possible to have an AI write code for you. In this article, we'll build a Code Generative AI model f [#Generative AI](/blog/tags/generative-ai)[#Code Generation](/blog/tags/code-generation)[#AI in Software Development](/blog/tags/ai-in-software-development)+6 tags [read more](/blog/post/building-a-code-generative-ai-model) [![GraphRAG Explained: Building Knowledge-Grounded LLM Systems](/_astro/hero.BdGCX8ya_1gL61X.webp)](/blog/post/graphrag-explained-building-knowledge-grounded-llm-systems) ## [GraphRAG Explained: Building Knowledge-Grounded LLM Systems](/blog/post/graphrag-explained-building-knowledge-grounded-llm-systems) - [Mohammad Abu Mattar](/authors/mohammad-abu-mattar) - [Artificial Intelligence](/blog/categories/artificial-intelligence) - [Machine Learning](/blog/categories/machine-learning) - [Large Language Models](/blog/categories/large-language-models) - [Knowledge Graphs](/blog/categories/knowledge-graphs) - [RAG Systems](/blog/categories/rag-systems) The world of artificial intelligence is moving fast. We've gone from being amazed that Large Language Models can write a poem to wanting them to be deeply grounded in factual truth. While these models [#GraphRAG](/blog/tags/graphrag)[#RAG](/blog/tags/rag)[#LLM](/blog/tags/llm)+7 tags [read more](/blog/post/graphrag-explained-building-knowledge-grounded-llm-systems) [![REST API vs RESTful API: Architecture and Constraints Explained](/_astro/hero.D7ffsaFk_ZsjslT.webp)](/blog/post/rest-api-vs-restful-api-architecture-and-constraints-explained) ## [REST API vs RESTful API: Architecture and Constraints Explained](/blog/post/rest-api-vs-restful-api-architecture-and-constraints-explained) - [Mohammad Abu Mattar](/authors/mohammad-abu-mattar) - [API Development](/blog/categories/api-development) - [Web Architecture](/blog/categories/web-architecture) - [Software Engineering](/blog/categories/software-engineering) - [Backend Development](/blog/categories/backend-development) Introduction REST API and RESTful API get used interchangeably, but they aren't quite the same thing. This post covers the difference, REST's constraints, and what they mean for how you design an [#REST API](/blog/tags/rest-api)[#RESTful API](/blog/tags/restful-api)[#API Design Principles](/blog/tags/api-design-principles)+6 tags [read more](/blog/post/rest-api-vs-restful-api-architecture-and-constraints-explained) [![Software Engineering Principles Every Developer Should Know](/_astro/hero.D6DACa0__Z5aYys.webp)](/blog/post/software-engineering-principles-every-developer-should-know) ## [Software Engineering Principles Every Developer Should Know](/blog/post/software-engineering-principles-every-developer-should-know) - [Mohammad Abu Mattar](/authors/mohammad-abu-mattar) - [Software Engineering](/blog/categories/software-engineering) - [Programming Principles](/blog/categories/programming-principles) - [Code Quality](/blog/categories/code-quality) - [Best Practices](/blog/categories/best-practices) Some software engineering principles hold up no matter what stack you're using. They guide you toward maintainable, efficient code. Here's a look at why every developer should know them. What is t [#DRY Principle](/blog/tags/dry-principle)[#KISS Principle](/blog/tags/kiss-principle)[#YAGNI Principle](/blog/tags/yagni-principle)+5 tags [read more](/blog/post/software-engineering-principles-every-developer-should-know) 6 related posts