Copilot Studio: Adaptive Cards Home Loan
Currently I am sharing my knowledge with the Power Platform, with PowerApps and Power Automate. With over 8 years of experience, I have been learning SharePoint and SharePoint Online
Microsoft expert on Copilot Studio agents with Adaptive Cards, dynamic JSON inputs and Power Fx EMI loan calculator
Key insights
- Copilot Studio + Adaptive Cards: Use Microsoft Copilot Studio with Adaptive Cards to build interactive in-chat forms that collect loan inputs and return results without leaving the conversation.
Adaptive Cards use JSON to define UI elements like fields and buttons, making the agent experience seamless. - Setup steps: Create a new Copilot Studio agent, add an "Ask with Adaptive Card" node, design the card in the built-in designer or paste JSON, and include a Submit button so the agent receives user inputs.
Keep the card simple: fields for loan amount, interest rate, and tenure help users respond quickly. - Input fields & output variables: Use types such as Input.Number for amounts and rates, and Input.ChoiceSet for tenure options. Assign clear IDs and placeholders to each field.
Copilot Studio auto-creates output variables from card inputs, letting you reference values directly in logic nodes. - Calculation logic (EMI): Convert annual interest to a monthly rate and apply the standard loan formula to compute monthly payment. For example: payment = round(principal * (r * (1 + r)^n) / ((1 + r)^n - 1), 2) where r = annualInterest / 1200 and n = months.
Build this using Power Platform expressions or expression nodes in the agent flow. - Dynamic cards & JSON trick: Turn JSON card templates into dynamic inputs so the agent adapts fields at runtime. This trick helps reuse card layouts and populate options or defaults based on context.
Dynamic inputs simplify maintenance and let the agent present tailored forms. - Testing, branching, and UX: Use the Copilot Studio test pane to preview cards and validate calculations. Add condition nodes to handle invalid entries, eligibility checks, or alternate flows.
Support skipping cards and topic switching to keep conversations flexible and improve user experience.
Overview: A Practical EMI Agent in Copilot Studio
In a new you_tube_video, author Andrew Hess - MySPQuestions walks viewers through building a home loan calculator inside Copilot Studio. The video frames the project as a learning exercise, not legal or financial advice, and focuses on the nuts and bolts of assembling an end-to-end agent. Importantly, Hess shows how a few careful steps can turn user inputs into a reliable EMI (equated monthly installment) result, all within a conversational flow.
As the tutorial progresses, it highlights chaptered segments that make it easy to follow: from triggering the agent, to the first adaptive card, to variable handling, a second card, a trick for dynamic cards, and final testing. Consequently, even newcomers can track progress and revisit sections as needed. The pacing is steady and objective, which suits the hands-on nature of the build.
How Adaptive Cards Drive the Experience
Hess centers the solution on Adaptive Cards, which are JSON-defined UI snippets that collect inputs directly in the chat experience. Because the card fields map to output variables automatically, the agent can react to user entries without extra wiring. Moreover, the design supports labels, placeholders, and validation to guide users through loan amount, interest rate, and tenure.
By keeping interactions inside the conversation, the video shows how to reduce friction and avoid redirects to external pages. In addition, the approach improves consistency, since the same JSON-backed card can be reused or extended across agent flows. This structure is especially helpful when you need to branch based on user choices or validate data before running calculations.
Step-by-Step Logic and Calculation
The build starts with creating a fresh agent and adding an “Ask with Adaptive Card” node to gather the three inputs: principal, annual interest, and term. Next, Hess demonstrates how Copilot Studio turns card inputs into variables you can reference in messages and conditions. He adds a second card where needed and illustrates a simple method to move from plain JSON to Dynamic Inputs that bind cleanly to the flow.
For the math, the video uses Power Platform expressions to implement the standard annuity formula. The logic converts the annual interest to a monthly rate, applies a power function for compounding, and rounds the result for clear currency output. Although the exact syntax lives in the expression editor, the steps are easy to follow and are explained in plain language.
What’s New in Copilot Studio
Hess notes that recent updates help streamline this pattern. A built-in Adaptive Card Designer reduces the need to bounce between tools, thus speeding up iteration. He also points to stronger support for condition-driven workflows, which makes it easier to guide users down different paths based on their entries.
Additionally, the agent can let users skip a card or even switch topics without getting stuck, which improves the overall conversation. These improvements matter because they cut the time from prototype to testable experience. In turn, builders can focus more on logic and less on plumbing.
Tradeoffs, Challenges, and Testing
Despite the benefits, the video makes clear there are tradeoffs. Static cards are simple to set up, yet they can become rigid as requirements grow; meanwhile, dynamic cards add flexibility but demand careful variable naming and validation. There is also a balance between showing enough fields to be helpful and overwhelming the user with too many choices.
On the calculation side, rounding and formatting choices affect user trust, so testing is vital. The chapter on “Testing for Correctness” underscores edge cases like zero or very small interest rates, long tenures, and out-of-range inputs. Consequently, a good practice is to validate data early and present clear error messages before performing the math.
Why It Matters for New Builders
For those new to Copilot Studio and Adaptive Cards, this you_tube_video offers a compact blueprint: collect inputs, transform them with expressions, and return a concise result. Because the pattern is generic, you can reuse it for other calculators or decision trees beyond loans. Furthermore, the conversational format can increase completion rates compared to traditional forms.
Ultimately, the tutorial demonstrates how to balance usability, correctness, and maintainability in a small but complete solution. It clarifies where to start, how to iterate, and which pitfalls to test. As a result, viewers get a realistic path from first card to final answer—without leaving the chat experience.
Keywords
Copilot Studio agent tutorial,Adaptive Cards home loan calculator,build Copilot agent with Adaptive Cards,Microsoft Copilot Studio tutorial,home loan calculator bot,Copilot Studio Adaptive Cards example,mortgage calculator Copilot agent,Copilot Studio developer guide