<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by João Sousa on Medium]]></title>
        <description><![CDATA[Stories by João Sousa on Medium]]></description>
        <link>https://medium.com/@neves.sousa?source=rss-c1f02a8b2da6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*MraZBrlIkdFsQicQsBHV7w.jpeg</url>
            <title>Stories by João Sousa on Medium</title>
            <link>https://medium.com/@neves.sousa?source=rss-c1f02a8b2da6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 15:13:07 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@neves.sousa/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Build the Machine That Builds the Applications]]></title>
            <link>https://medium.com/@neves.sousa/build-the-machine-that-builds-the-applications-31a571c29bde?source=rss-c1f02a8b2da6------2</link>
            <guid isPermaLink="false">https://medium.com/p/31a571c29bde</guid>
            <category><![CDATA[outsystems]]></category>
            <category><![CDATA[outsystems-development]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[adlc]]></category>
            <dc:creator><![CDATA[João Sousa]]></dc:creator>
            <pubDate>Tue, 10 Nov 2026 14:22:34 GMT</pubDate>
            <atom:updated>2026-11-10T16:19:15.708Z</atom:updated>
            <content:encoded><![CDATA[<p><em>What OutSystems developers need to change to thrive in the agentic space, and why the window to do it is open right now</em></p><p><em>This article also appears on the </em><a href="https://www.acceleratedfocus.com/post/build-the-machine-that-builds-the-applications"><em>Accelerated Focus Blog</em></a><em>.</em></p><p><a href="https://www.acceleratedfocus.com/"><em>Accelerated Focus</em></a><em> is an OutSystems Gold Partner and a Claude Certified Partner. We combine OutSystems and Claude to turn business challenges into working software that helps our customers scale. We don’t just build apps. We build businesses.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oxzf-BQhSXO82h1PjZUJ0g.png" /><figcaption>Build the machine that builds the applications</figcaption></figure><p>AI Agents arrived, and I watched my Low Code team react: some people changed fast, while others are not there yet.</p><p>I have been working on changing how my team works, but the wider OutSystems community needs to change too, and faster than most of us think.</p><h3>The comfort of low code</h3><p>I’ve been building enterprise software for 25 years, and for a big part of that time OutSystems has been my home. I love the platform because it lets us start a project in low code and finish it in low code, and most of our projects fit that shape perfectly. That, however, is exactly the problem.</p><p>When the tool gives you everything you need, you stop looking beyond it. I don’t have numbers to prove it, but I have years of watching good developers live very comfortably inside the low code space. They are rarely exposed to anything outside it. Over time, curiosity fades, along with the habit of spending a few hours a week on things that are not on the backlog.</p><p>OutSystems is partly responsible for this, in the best possible way, because it made us productive. But there is something I keep repeating to my team: you cannot take the developer out of the low code developer. Low code is how we build, but being a developer is who we are, and developers who stop being curious get left behind.</p><p>I’ll be honest about my own path here. Working beyond low code, in .NET, Azure and other stacks, gave me more agility when agents arrived. I already knew where my gaps were, so I knew what to learn to fill them.</p><h3>My team is changing</h3><p>Some of my developers already work in a different way every day. They use AI to do their jobs better, make the most of it, and challenge how we have always done things. They are the proof that this way of working pays off.</p><p>Others are not there yet, and there are valid reasons for that:</p><ol><li><strong>Time.</strong> Project deadlines don’t pause for learning.</li><li><strong>Mindset.</strong> Change is uncomfortable.</li><li><strong>Availability.</strong> The people who could learn are often the busiest.</li><li><strong>Background knowledge.</strong> Someone who has only known low code has more ground to cover.</li></ol><p>None of these is a lack of talent, and all of them can be solved.</p><h3>You won’t prompt your way into an application</h3><p>There is a misconception I hear all the time: people think the agentic space is about getting good at prompting, as if a clever prompt were enough to get an app. That is not how it works.</p><p>We are not going to build applications with prompt engineering. We are going to build applications by building the machine that builds the applications.</p><p>Prompting is where everyone starts, and that is fine. But a real agentic pipeline is not one prompt. It is a set of skills, activities and agents, each doing one job well, chained together to take you from a requirement to working software. Someone has to design, build, test, govern and improve that machine, and that someone should be you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a35wWZCXU7zWHN25tD-t1A.png" /><figcaption>A clever prompt is not a delivery pipeline</figcaption></figure><h3>What you need to learn</h3><p>So what does a low code developer need to change? I see three groups of skills.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2ss8_9NhERXRVJ24xLD7zg.png" /><figcaption>Three skill group for the agentic developer</figcaption></figure><p><strong>First, the bare minimum of AI.</strong> You don’t need a PhD, but you do need to understand how models are created, how you interact with them, what they are good at and where they fail. You need to know the common patterns for using them, especially when you work with their APIs directly. Without this foundation, everything else feels like magic, and you can’t build reliable systems on magic.</p><p><strong>Second, learning to put agents to work on your behalf.</strong> Harnesses like Claude Code, Cursor and AWS Kiro change the way you reach a deliverable. The goal is often the same as before, but the path is completely different. You stop doing every step yourself and start designing the steps an agent will do for you. That means writing skills, wiring tools through MCP, deciding what runs in isolation and what needs the full conversation, and checking that the output is actually right. It is a different way of thinking, and it takes practice.</p><p><strong>Third, the human skills.</strong> This one surprises people. For years, many developers worked like a mouse in a basement, waiting for specifications to be slid under the door, and that model is over. When agents can do much of the building, the value moves to understanding what to build and why. You need to get out of your chair, talk to the business and the customer, and ask why, then ask why again. The developers who master this will be the ones designing the machines, while the ones who don’t will fall behind.</p><h3>What this looks like in practice</h3><p>Let me make this concrete with something I designed and implemented at my organization.</p><p>At Accelerated Focus, I maintain a plugin repository for our Low Code team, built on Claude. It is a collection of skills that encode how we work. One skill acts as an OutSystems 11 architecture advisor, a consultant you can go back and forth with while you design. On one of our customer projects, I have an agent that runs every day on a schedule inside Claude. It uses ODC AX (Agent Experience) to look into the factory and see what people have been publishing and how often, and then a skill writes those insights into an artifact in a format I defined, so I can follow how the developers are performing without chasing anyone for updates. Each skill has a carefully written description, because that description decides when the agent picks it up, and if you get it wrong the skill never fires.</p><p>None of this is prompt engineering. It is plain engineering, the same discipline we have always had, pointed at a new target, and it is exactly the kind of work I want every developer on my team to be able to do.</p><p>The best moment, though, came from someone on my team. I asked one of my team members to take O11 AX and pull as much information as he could from a module and its application. Instead of stopping at the extraction, he built a skill around it. That skill now feeds a contextual graph of our applications, a map our agents can use to understand what already exists before they touch anything. He went from using a tool to building part of the machine, and that is the shift I’m talking about.</p><h3>The gap is our window</h3><p>Here is the part that gives me hope: there is a gap today between what you can already do with agents and what organizations are ready to absorb. The technology is moving faster than companies can change their processes, contracts and teams. Most of our customers are not yet asking for agentic delivery. Some are already dreaming of having it.</p><p>I don’t see that gap as a problem but as a gift, because mastering this takes months, not days. The gap is the time we have to learn before agentic delivery becomes the default. If you start now, you will be ready when your organization catches up, but if you wait for your company to ask you, you will be learning in a hurry while someone else is already delivering.</p><p>So this is my call out: get out of your chair and use the window.</p><h3>The questions we need to answer</h3><p>I’ll finish with questions, not answers. I have ideas about all of them, but I think the questions matter more right now.</p><p>What will team sizes look like when one developer can run a machine that does the work of many? How will we organize our delivery model? Do we put an agentic flow on top of the agile framework we already know, or do we rebuild it? What do we keep? What do we replace? What do we remove entirely?</p><p>I don’t think anyone has the full answer yet, but I know who will help find it: the developers who started building the machine early.</p><p>I truly hope that includes you!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=31a571c29bde" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Grounding Layer: Why OutSystems Opening Up Changes Everything]]></title>
            <link>https://medium.com/@neves.sousa/the-grounding-layer-why-outsystems-opening-up-changes-everything-de4af48678ea?source=rss-c1f02a8b2da6------2</link>
            <guid isPermaLink="false">https://medium.com/p/de4af48678ea</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[outsystems]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[João Sousa]]></dc:creator>
            <pubDate>Fri, 24 Apr 2026 17:23:28 GMT</pubDate>
            <atom:updated>2026-04-24T17:23:28.932Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Tools will change in six months. Models will change in three. What stays with you is the context you have built, and that is the part nobody is talking about enough.</em></p><p><strong>TL;DR</strong></p><p>Tools and models will keep changing. What stays with you is the context you have built: your architecture, your business rules, the way your systems fit together. The OutSystems Enterprise Context Graph, and the decision to open it up to agents like Claude Code, Codex, and Cursor, matters because it turns that context into the grounding layer any agent can plug into. Openness is not a feature. It is the thing that protects you when the tooling layer shifts again, and it only works if the governance and rails underneath stay in place.</p><p>I was scrolling X the other day and a post from Andrej Karpathy stopped me cold. He was making the point that we are all still designing software as if the user on the other end is a human clicking through screens we carefully arranged for them. And suddenly, in a world where agents are doing more and more of the work, that pattern feels <em>rude</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kTDySFdh6dd_DJmsRI-7LQ.png" /><figcaption><em>Andrej Karpathy on X. The post that framed how I have been thinking about the last six months of AI tooling.</em></figcaption></figure><p>Now, I want to be careful here. UI is not going away. For a huge number of users, the interface is the product, and a well-designed screen is still the best way to get something done. That is not changing. What <em>is</em> changing is that a growing class of users, call them developers, architects, builders, the people who are about to spend the next few years creating the agents that power everything else, do not need a UI for most of what they do. They need a platform that talks back programmatically. They need something an agent can reach into, understand, and act on without having to pretend it is a human clicking buttons.</p><p>That shift is the real story behind the Agentic Systems Engineering announcement. And the part of it I want to talk about, because I do not think it gets the attention it deserves, is openness.</p><h3>The uncomfortable truth every architect is feeling right now</h3><p>Let me say the quiet part out loud. The tools I am using today are almost certainly not the tools I will be using in six months. The models change faster than that. Every week there is a new repository, a new agent framework, a new way of working that promises to be better than what I was using on Monday. Sometimes it is. Sometimes it is not. Either way, I cannot tell you with any real confidence which assistant I will have open in my second monitor by the end of the year.</p><p>This is not a complaint. This is just the reality of the space right now. But it raises a hard question for anyone doing serious enterprise work: if the tooling layer is this volatile, what do I actually build on that will survive the next shift?</p><h3>Tools move. Context stays.</h3><p>This is the thesis. The data that grounds those models is where continuity lives. Your architecture, your domain model, your business rules, the way your systems actually fit together. That is yours. That is what travels with you when Mentor gets a new capability, when Claude Code ships a breaking update, when some tool I have never heard of becomes the new default three months from now.</p><p>I think about it in layers.</p><p>There is <strong>personal intelligence</strong>, the patterns I have learned over years of building, the prompts that work for me, the way I like my agents to behave. That travels with me from project to project, job to job. It is mine.</p><p>Then there is <strong>team intelligence</strong>, the shared version of that same idea. The conventions my squad has agreed on, the codebase knowledge we draw from, the shortcuts and guardrails we have built up together. That travels with the team.</p><p>And then there is the <strong>proprietary layer</strong>. The architecture of the applications, the business rules that run the company, the integration patterns that took years to stabilise, the domain language nobody outside the organisation understands. That one is not yours and it is not the team’s. It belongs to the organisation, and it must never be rebuilt from scratch every time a new tool shows up at the door.</p><p>If any of those three layers is weak or missing, your agents are guessing. They will get the happy path right and then quietly make a mess of everything else. I have seen it. Most of us have.</p><h3>Why a closed ecosystem quietly breaks this idea</h3><p>Here is the trap I want to flag, because it is easy to walk into. If the only way to use AI inside your platform is to use that platform’s single built-in assistant, you have just reintroduced vendor lock-in with a new coat of paint. Maybe it is a very good assistant. Maybe it is the best one available today. It will not be the best one available in a year.</p><p>More importantly, different tools are good at different things. I want to use Claude Code for the things Claude Code is best at. I want Mentor for what only Mentor can do inside the OutSystems platform. I want Cursor, or Codex, or whatever comes next, when the job calls for it. That is not me being difficult. That is me doing my job well.</p><p>None of that works if each tool has to build its own private understanding of my system. If Claude Code has one map, Mentor has a different one, and Cursor has a third, then I am not orchestrating agents, I am refereeing them. And at enterprise scale, that fragmentation is how you get AI sprawl, the exact kind that quietly introduces risk you will not see until it is already in production.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*Bm7XZKDaVepr8-nlP6BYIw.png" /><figcaption><em>The OutSystems Enterprise Context Graph: the grounding layer that lets any agent plug into the same shared understanding of your system. Image credit: OutSystems.</em></figcaption></figure><h3>What OutSystems is actually opening up</h3><p>This is where the announcement matters, and where I want to be precise about what it is and what it is not.</p><p>The Enterprise Context Graph is a knowledge layer on top of your applications. It holds the structure and architecture of your system: entities, actions, timers, screens, widgets, how they depend on each other, and the metadata for each of them. Any agent that can plug into it gets the same map. Mentor uses it today. OutSystems has announced that other coding agents are next, and if that opening up is done right, not just a few shallow APIs but real access to the context, that is the piece I have been waiting for.</p><p>Because it means I no longer have to choose. I do not have to pick between Mentor or Claude Code, between the OutSystems assistant or Cursor. I can use all of them, working in the same system, following the same rules, grounded in the same context. The tooling layer becomes genuinely pluggable, and the grounding layer stays intact underneath.</p><p>That is what real openness looks like. Not a marketing line. A knowledge layer any agent can ground itself on, and a runtime that keeps the rails in place while they do it.</p><h3>The part nobody is talking about enough: governance</h3><p>Openness without governance is chaos. Governance without openness is a cage. You need both, and the combination is much rarer than people realise.</p><p>OutSystems has spent more than two decades building the governance and cloud management layer of the platform. Deployments, observability, access control, audit trails, the dull but critical machinery that makes enterprise software actually work at scale. That was already there. What the ASE announcement does is give agents, any agent, a way to plug into that machinery instead of trying to recreate it badly on the fly.</p><p>When an agent in a closed-world tool stands up a deployment pipeline from scratch, it will miss edge cases. It will forget the audit step. It will happily make a change that should have triggered a review. Not because the agent is malicious, but because it has no idea the review was supposed to happen. It was never told, and it had no way to find out.</p><p>When the same agent operates inside the OutSystems grounding layer, that context is already there. The guardrails are already wired. The agent is not inventing the enterprise. It is working inside one. That difference is not cosmetic. It is the difference between a proof of concept and a system you can actually run.</p><h3>What this means for the day to day</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bsltFP-8vTPAaMrtWAmm2g.png" /><figcaption><em>The shape of the work is changing. Less mechanical building, more architectural thinking, more time spent on the questions that actually matter. (AI Generated images using Google Gemini)</em></figcaption></figure><p>I want to be honest about what this changes for us as developers and architects, because I think some of the discourse around AI in development is either too doomy or too giddy.</p><p>The mechanical parts of the job are going to shrink. Wiring up yet another CRUD screen, translating a clear business requirement into boilerplate, rebuilding the same integration pattern for the fifth time this year, those get compressed. Agents are good at that now, and they are going to get better.</p><p>What expands is the part that actually requires a human. What should we build? Why does it matter to the business? Is this the right decision given everything else going on? How do the systems connect, where are the tradeoffs, where does risk live? Those questions are not going anywhere. If anything, we finally get the time to think about them properly instead of squeezing them in between tickets.</p><p>The job title might change. The role is moving from “builder of applications” to “orchestrator of intelligent systems.” But the core of it, judgement, taste, architectural thinking, understanding the business, is more valuable than ever. I genuinely feel lucky to be doing this work at this moment.</p><h3>Closing</h3><p>I think the platforms that will win the next five years are not going to be the ones with the flashiest AI assistant. The model behind that assistant will be commoditised faster than any of us expect. The platforms that win will be the ones with the strongest grounding layer and the confidence to let any agent plug into it.</p><p>Openness is not a feature. It is an admission that no single tool is going to be the right tool forever, and that the thing worth protecting is not the tool but the context underneath it. That context is yours. Build it well, keep it clean, and let the tools come and go around it.</p><p>That is the bet I am making. And after watching this space for a while, it is the only one I think actually holds up.</p><p><em>This article is also posted in the </em><a href="https://www.acceleratedfocus.com/post/the-grounding-layer-why-outsystems-opening-up-changes-everything"><em>Accelerated Focus Blog</em></a><em>.</em></p><p><a href="https://www.acceleratedfocus.com/"><em>Accelerated Focus</em></a><em>, recognized as </em><a href="https://www.acceleratedfocus.com/post/accelerated-focus-awarded-2023-outsystems-partner-of-the-year"><em>Partner of the Year 2023</em></a><em>, focuses on solving business challenges with low-code, delighting employees, and fostering partnerships with organizations looking to grow and transform because doesn’t just build apps — builds businesses.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de4af48678ea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Shipping a DevOps Wizard with ODC Workbench (our EAP story)]]></title>
            <link>https://medium.com/@neves.sousa/shipping-a-devops-wizard-with-odc-workbench-our-eap-story-8968a41d912c?source=rss-c1f02a8b2da6------2</link>
            <guid isPermaLink="false">https://medium.com/p/8968a41d912c</guid>
            <category><![CDATA[outsystems]]></category>
            <category><![CDATA[outsystems-odc]]></category>
            <category><![CDATA[outsystems-mvp]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[outsystems-development]]></category>
            <dc:creator><![CDATA[João Sousa]]></dc:creator>
            <pubDate>Wed, 17 Sep 2025 13:24:34 GMT</pubDate>
            <atom:updated>2025-10-09T17:01:13.117Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This article is also posted in the </em><a href="https://www.acceleratedfocus.com/post/shipping-a-devops-wizard-with-odc-workbench-our-eap-story"><em>Accelerated Focus Blog</em></a><em>.</em></p><p><a href="https://www.acceleratedfocus.com/"><em>Accelerated Focus</em></a><em>, recognized as </em><a href="https://www.acceleratedfocus.com/post/accelerated-focus-awarded-2023-outsystems-partner-of-the-year"><em>Partner of the Year 2023</em></a><em>, focuses on solving business challenges with low-code, delighting employees, and fostering partnerships with organizations looking to grow and transform because doesn’t just build apps — builds businesses.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gDdKAIYehjKydT0WaDTd4A.png" /><figcaption>Screenshot from the tiny one page app creating a deployment plan</figcaption></figure><h3>TL;DR</h3><ul><li>Accelerated Focus was invited into the OutSystems Workbench Early Access Program (EAP). This article is my hands-on walkthrough and a field report of what already feels production-shaped.</li><li>The demo app is a single screen: a chat UI where I ask a DevOps “wizard” to list environments, inspect apps, and kick off deployments from <strong>Development → Production</strong> using Lifetime v2 wrappers.</li><li>Workbench let us compose: <strong>messages</strong> (system + user), <strong>memory</strong>, <strong>grounding</strong>, and <strong>action calling</strong> (our server actions) into a single agent task. Governance and observability guard the sharp edges.</li><li>If you’re wondering how to bring agentic patterns into real app workflows, without duct tape, this is a good blueprint. And yes, there are screenshots and the agent’s system prompt below.</li></ul><h3>Why Workbench (and why now)</h3><p>AI in enterprise apps moved from <em>“ask a bot”</em> to <em>“delegate a job”</em>. Agents don’t just answer; they <strong>decide and act</strong> on query data, call functions, persist context, and loop until the job is done. OutSystems’ roadmap formalizes this with three stacked capabilities in ODC: <strong>AI model &amp; data integration</strong>, <strong>agent lifecycle management</strong>, and <strong>agent orchestration</strong>. That layering matters and you get a place to connect models and knowledge, build/monitor agents, and string them into workflows.</p><p>But great power needs guardrails. Enterprise teams need cost control, access policies, differentiated endpoints per stage, and telemetry you can actually use. Workbench ships with that governance/observability spine so you can move fast without inventing your own rails.</p><p>The EAP’s intent is simple: let a small cohort build real use cases, pressure-test the experience, and feed back before GA. We joined to put a DevOps agent in the wild and report back. (If you’re curious, EAP participants are expected to try concrete use cases, invest time, and share stories like this one.)</p><h3>Quick IDE walkthrough: building an AI Agent in ODC Workbench</h3><p>You don’t start with a blank prompt; you start with a <strong>scaffold</strong>. Workbench gives you an AgentTask canvas where the usual moving parts, grounding, messages, model call, memory, are first-class blocks you can wire up without glue code.</p><h3>1) Create an Agent</h3><p>Name it like intent (e.g., <strong>DevOps Deployment Assistant</strong>). Pick the stage’s model endpoint (Dev vs Prod) so governance isn’t an afterthought.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6WWjgcr1LFG3OVvneQHa0g.png" /><figcaption>ODC Studio — Create a new Agent</figcaption></figure><h3>2) Choose the AI Model</h3><p>The models that are available here are the ones configured in the ODC Portal. You can change it later if you want. Finding the right model for your Agent is key for the success of your use case.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yu-A5UEWrN0qeEoHiWII3A.png" /><figcaption>ODC Studio — choose the AI Model</figcaption></figure><h3>3) AI model interface</h3><p>The Agent template scaffolds the server actions you need to start. The Service Action, that serves as interface to your AI Agent, gets the name of the agent Call…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dQFEpI-EZPIVCJKD45DaOw.png" /><figcaption>Service action — interface with the AI Agent</figcaption></figure><p>AgentTask orchestrates the agent’s steps (grounding → messages → model call → memory).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1tItwXJlqO-NPDH6G-CTrA.png" /><figcaption>AgentTask orchestration action</figcaption></figure><h3>4) Grounding: choose what facts the model can “see”</h3><ul><li><strong>What it is</strong>: You fetch relevant passages from a knowledge source, stuff them into the prompt, and tell the model to answer only from that context, ideally with citations. It’s mainly a <strong><em>hallucination-reduction &amp; correctness technique</em></strong>.</li><li><strong>When to use</strong>: Q&amp;A over policies, manuals, PDFs, tickets, etc.; you want answers backed by your content and/or live search results.</li><li><strong>For this use case:</strong> If you have a knowledge base that has guidelines on how to properly write release notes for deployment plans, why not use it here?</li></ul><h3>5) BuildMessages: assemble the conversation contract</h3><ul><li><strong>What it is:</strong> You compose the messages the model sees: <strong>system</strong> (rules, persona, allowed tools), <strong>user</strong> (what they typed), plus any <strong>grounding snippets</strong> and lightweight memory. This is where you lock tone, guardrails, output format, and include IDs (e.g., sessionId). Think of it as the agent’s <strong>runbook</strong> in prose.</li><li><strong>When to use:</strong> Always. Use it to keep answers consistent, reduce prompt-drift, and make tool-choice easier (clear capabilities → better action calling). Great for enforcing defaults (“Dev → Prod unless stated”) and required questions when inputs are missing.</li><li><strong>For this use case:</strong> The system prompt sets the geeky DevOps voice, lists available actions, enumerates deployment statuses, and reminds the agent that the pipeline has only <strong>Development</strong> and <strong>Production</strong>. I also inject the sessionId for traceability and ask for clarification if the app <strong>key</strong> isn’t provided.</li></ul><h3>6) Call Agent Core (a.k.a. give the model safe hands)</h3><ul><li><strong>What it is:</strong> The actual model call. The model can decide to invoke your registered tools with typed arguments, Workbench validates the calls, and you get structured outputs and traces. In short: the model thinks; <strong>tools act, </strong>within safe, auditable boundaries, and also, you have the opportunity to test your system prompts directly from the IDE.</li><li><strong>For this use case:</strong> We expose Lifetime v2 wrappers. The common path is list → detail → <strong>create plan</strong> → <strong>monitor</strong>. If the plan hits needs_user_intervention, the agent explains what’s blocking and offers next steps.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*srAyoGZu959Oama8ByUdTQ.png" /><figcaption>System Prompt Testing screen</figcaption></figure><h3>7) Memory: load, store, and (if needed) erase</h3><ul><li><strong>What it is:</strong> Lightweight, session-scoped state that survives across turns. You <strong>LoadMemory</strong> at the start and <strong>StoreMemory</strong> at the end to ideally store summaries and key slots (not full transcripts). An <strong>erase</strong> tool lets the user reset the thread cleanly.</li><li><strong>When to use:</strong> Multi-turn flows where earlier choices matter, selected app, chosen environments, last plan key/status, user preferences. Avoid persisting secrets or bulky text; set sensible TTLs; treat memory like a concise checklist the agent can rely on.</li></ul><p>The devil is on the details, so the best you have to do is jump into ODC Studio and start building your Agents. While you wait for GA, let me walk you through the how to of the app I created.</p><h3>The use case: a teeny, single-page “DevOps Wizard” (intentionally 90% shipped)</h3><p>Confession time: this app is <strong>not</strong> fully finished. On purpose.</p><p>The EAP brief for us was <em>breadth over polish</em>! Ttry as many agentic patterns as we can in the time we’ve got, learn, and report back. I’d rather show you the bones and let you run with it than ship a black box. Think of this as a <strong>workbench specimen</strong> and a teaser for you to finish the last mile.</p><p>On the other hand, I also didn’t want a <em>meh</em> demo. I wanted the minimum lovable tool I’d actually keep open while working. It still needs a final polish!</p><p><strong>What’s in and working today: One page. One input. Real authority.</strong> I type: “Deploy JoaoSousaSandbox to Prod.” and the agent:</p><ol><li>identifies the environment,</li><li>finds the application,</li><li>creates a deployment plan,</li><li>monitors the status until it’s <strong>running / needs_user_intervention / aborted / finished_successful / finished_with_warnings / finished_with_errors</strong>,</li><li>gives me geeky, friendly updates, and</li><li>can wipe its memory on request to start fresh.</li></ol><blockquote><em>The pipeline has only </em><strong><em>Development</em></strong><em> and </em><strong><em>Production</em></strong><em> (Partner environments by design). If I don’t specify the source, the agent assumes Dev → Prod.</em></blockquote><h3>The system prompt (as-is)</h3><pre>You are a helpful assistant and will support the user with the deploying of application in the Accelerated Focus pipeline. <br>Here are the list of actions you can do:<br>- You are able to list environments in the pipeline<br>- You are able to list applications and the environments where they are published. This tool has the Application Name as filter, if needed. When not stated, the list is order alphabetically. <br>- You are able to list the information of a single application, given its key, but if you don&#39;t have the key this is not the tool for you. There are other ways.<br>- Deploy applications from the requested original environment to the destination environment. Actions to execute:<br>    1. Get the Application detail. <br>    2. Create the Deployment plan.<br>    3. You have a tool to validate the status of the deployment plan. The following status can occur: “saved”, “running”, “needs_user_intervention”, “aborted”, “aborting”, “finished_successful”, “finished_with_warnings” or “finished_with_errors”.<br>    Observation: If this information is not provided, be aware that the AF pipeline only has 2 environments: Development and Production.<br><br>As supporting tools, you can:<br>- Erase the memory of the agent (all the messages in the session thread). <br><br>You will be answering as a Dev Ops Developer: in a cool and geeky way.<br><br>For reference of this thread, here is your sessionId: &lt;SessionId&gt;</pre><h3>The tools behind the curtain</h3><p>I exposed a handful of <strong>Service Actions</strong> where some wrap the OutSystems <strong>Lifetime API v2</strong> others have a more supporting role to the AI Agent capabilities:</p><ul><li>GetEnvironments — list pipeline envs</li><li>GetApplications — list apps (+ optional ApplicationName filter)</li><li>GetApplication — fetch one app by key (strict input)</li><li>CreateDeploymentPlan — create plan from source→target</li><li>GetDeploymentStatus — poll status of plan</li><li>EraseAIAgentMemory — reset session</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NHXvMaKTNIbDn4G1aQpy7g.png" /><figcaption>CallGPT5_Chat Server Action</figcaption></figure><p>These are exactly the sort of “agent tools” enterprise apps need: <strong>business-safe, permissioned, idempotent where possible, and logged.</strong></p><h3>Walkthrough: the wizard at work</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gDdKAIYehjKydT0WaDTd4A.png" /><figcaption>Screenshot from the tiny one page app creating a deployment plan</figcaption></figure><p>Here’s a typical chat turn (summarized from the screenshots):</p><ul><li><strong>“Hey wiz, can you list all environments?”</strong></li></ul><p>It calls GetEnvironments and answers with our two battlegrounds: <strong>Development</strong> and <strong>Production</strong> — with just enough personality to feel like a teammate, not a toaster.</p><ul><li><strong>“Deploy JoaoSousaSandbox to Prod; I made it for troubleshooting.”</strong></li></ul><p>The agent orchestrates: GetApplications (filter by name) → GetApplication (detail) → CreateDeploymentPlan. On success it sends me the <strong>Deployment Plan Key</strong> and asks if I want live monitoring.</p><ul><li><strong>“Yes — monitor it.”</strong></li></ul><p>It polls GetDeploymentStatus until the plan moves from <strong>saved</strong> → <strong>running</strong>, or escalates if it hits <strong>needs_user_intervention</strong>. Status enums and transitions are explained to the user in plain terms, which keeps the UX honest while still feeling… well, wizardly.</p><ul><li><strong>“Reset memory.”</strong></li></ul><p>This runs the EraseAIAgentMemory tool and confirms we’re back at zero.</p><p>Under the hood, the agent is following the exact <strong>agent development + reasoning + memory + tools</strong> pattern described in the Workbench EAP docs — only we wrapped those moves around a real DevOps task instead of a toy to-do list.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qM-K4kWGNOjlqGlWLv4biA.png" /><figcaption>Lifetime — Deployment plan created with the JoaoSousaSandbox</figcaption></figure><h3>Architecture at a glance</h3><ul><li><strong>UI</strong>: one screen, conversational layout (input + transcript).</li><li><strong>AgentTask</strong>: GetGroundingData → BuildMessages → CallGPT5_Chat (with tools) → StoreMemory → Response.</li><li><strong>Tools</strong>: server actions wrapping Lifetime v2.</li><li><strong>Governance</strong>: per-stage model endpoints + access control.</li><li><strong>Observability</strong>: tokens, latency, tool call logs; plus app traces.</li></ul><h3>What felt especially good</h3><p>What clicked immediately was how visual the wiring is. I can point a teammate at the AgentTask and they grasp the control flow in seconds. Tool boundaries feel crisp where inputs and outputs are typed, so the agent can only call what I expose, and dropping a sessionId into the system prompt gives us traceable, support-friendly transcripts.</p><p>Workbench isn’t just a single-agent studio; the roadmap points to <strong>multi-agent orchestration</strong>. Think agents collaborating side-by-side, passing work in sequence, or pausing for human checkpoints with traceability into <em>why </em>each step happened through reasoning traces and tool usage. In practice, that means a Release Manager agent coordinating tests and approvals before a deploy, a support flow where a Retrieval agent, a Classification agent, and an Action agent share the baton, or even sales ops agents that pull live account intel across systems before drafting outreach. Same canvas, bigger cast.</p><h3>Wrap up!</h3><p>Leave you with a mission, should you choose to accept it → Forge Challenge</p><p>If you already own an internal workflow with APIs and clear guardrails, you’re ready for this pattern. Platform and DevOps teams can automate environment checks, deployment planning, and rollback assists without surrendering control. Corporate services can move from “chat” to <strong>act</strong>,<strong> </strong>creating tickets, routing work, nudging approvals. Back-office operations can triage across systems and push the right buttons on behalf of the user, with the agent doing the drudge work and humans handling judgment.</p><p>Agentic AI is creeping into a sizeable chunk of enterprise apps over the next few years. The trick is bringing it in <strong>safely</strong> with lifecycle management, governance, and observability folded into the platform, not bolted on later. Workbench gives you the rails to scale from one helpful helper to a small ensemble without changing the mental model you used to build the first one.</p><p>Finish this idea and ship your agent to the <strong>OutSystems Forge</strong> so the community can poke, learn, and remix.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8968a41d912c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What If Your PDFs Could Talk? Building Search That Understands]]></title>
            <link>https://medium.com/@neves.sousa/what-if-your-pdfs-could-talk-building-search-that-understands-ac5441c05520?source=rss-c1f02a8b2da6------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac5441c05520</guid>
            <dc:creator><![CDATA[João Sousa]]></dc:creator>
            <pubDate>Wed, 28 May 2025 01:21:09 GMT</pubDate>
            <atom:updated>2025-05-28T01:21:09.056Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This article is also posted in the </em><a href="https://www.acceleratedfocus.com/post/what-if-your-pdfs-could-talk-building-search-that-understands"><em>Accelerated Focus Blog</em></a><em>.</em></p><p><a href="https://www.acceleratedfocus.com/"><em>Accelerated Focus</em></a><em>, recognized as </em><a href="https://www.acceleratedfocus.com/post/accelerated-focus-awarded-2023-outsystems-partner-of-the-year"><em>Partner of the Year 2023</em></a><em>, focuses on solving business challenges with low-code, delighting employees, and fostering partnerships with organizations looking to grow and transform because doesn’t just build apps — builds businesses.</em></p><p><strong><em>How OutSystems, AI Agents and Azure AI can turn a mess of documents into meaningful search experiences?</em></strong></p><p>We’ve all been there: surrounded by folders stuffed with scanned PDFs, eBooks, research articles, and loose files. Some are named sensibly, others are called <em>scan_0001.pdf</em> or <em>document_final_final_v2.pdf</em>. They’re spread across devices and cloud drives. And when you need something specific — fast — it becomes a digital treasure hunt.</p><p>That’s the inspiration behind <strong>Bookshelf AI</strong> — a <strong>white-labeled concept</strong> based on a real customer challenge we tackled recently. While this version is fictionalized for demo purposes, the problem it addresses — and the AI techniques behind it — are very real.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ast-cRhzrTWHpOWLemMz8A.png" /><figcaption>ODC Studio — Bookshelf AI application</figcaption></figure><h3>📚 The Real Problem</h3><p>This isn’t just a theoretical scenario — it’s a reality for teams and organizations across industries.</p><p>Whether it’s a legal department with case files, an HR team managing policy documents, or a field services unit archiving reports and forms, <strong>unstructured content is everywhere</strong>. And most of it is… a mess.</p><p>Here’s what we typically find:</p><ul><li><strong>PDFs without metadata</strong> — No title, no author, no creation date. Just a filename like <em>Final_Report_Updated_(1).pdf</em>.</li><li><strong>Scanned documents</strong> — Often saved as images inside PDFs, making them invisible to traditional text-based search engines.</li><li><strong>Inconsistent naming conventions</strong> — Some files are human-readable; others look like machine-generated gibberish (<em>scan_2045_a21.pdf</em>).</li><li><strong>Disorganized storage</strong> — Files scattered across email attachments, network drives, cloud shares, and personal folders.</li><li><strong>No common taxonomy</strong> — What one person labels “proposal,” another calls “brief,” and another “slide deck.”</li></ul><p>When someone needs to find a specific document — or worse, verify if a document exists at all — it can mean opening dozens of files manually, skimming pages, and trying to guess the intent behind the filename.</p><p>This kind of manual search doesn’t just waste time — it introduces <strong>risk</strong>. Missed insights, duplicate work, wrong versions, and non-compliance can all result from an inability to <strong>find and trust</strong> your documents.</p><p>And while keyword search is a helpful starting point, it falls short when:</p><ul><li>Words in the document don’t match the user’s query</li><li>The user doesn’t know exactly what terms to use</li><li>Context and meaning matter more than literal strings</li></ul><p>In short: <strong>manual organization doesn’t scale</strong>, and <strong>traditional search doesn’t understand</strong>.</p><p>That’s why we need a smarter, more intuitive approach — one that sees what’s in a document the way a human would, but works at machine speed and scale.</p><h3>💡 The Approach: Think Like a Human, Scale Like a Machine</h3><p>When we considered how to solve this challenge, we asked ourselves:</p><p><strong>“What would a highly organized person do?”</strong></p><p>They’d open each file, read through the content, mentally classify what it’s about, and then label it with a meaningful title and summary. They’d probably file it neatly under a relevant category and make it easy to search later.</p><p>The good news? That’s now something AI can do — at <strong>scale</strong>.</p><p>The approach we took in this prototype (Bookshelf AI) mimics this behavior using a combination of <strong>LLMs (Large Language Models)</strong> and <strong>semantic vector indexing</strong>. It works like this:</p><p><strong>1. Centralize</strong> all documents in one place — no matter how messy they are.</p><p><strong>2. Use AI to read and understand each file</strong> — even scans and unstructured documents, with the help of OCR (Optical Character Recognition).</p><p><strong>3. Extract key metadata</strong> — not just filename and size, but human-like labels:</p><ul><li>Title</li><li>Author</li><li>Document type (based on content themes or topics)</li><li>Year (estimated or extracted)</li></ul><p><strong>4. Format the output as structured JSON</strong> — ready to be indexed or stored.</p><p><strong>5. Expose all of this through a clean, OutSystems-powered UI</strong> — searchable by natural language, not technical filters.</p><p>What makes this powerful is the shift in thinking:</p><ul><li>From <em>“Where is this exact word in this exact file?”</em></li><li>To <em>“Which documents are most likely to be relevant to this idea I’m expressing?”</em></li></ul><p>This approach reduces reliance on rigid structure, replaces manual tagging, and empowers users to ask questions the way they naturally would — without needing to guess the “right” keywords.</p><p>It’s AI behaving like an efficient assistant who’s already read everything, knows what matters, and can surface it in seconds.</p><h3>🛠️ Behind the Scenes: OutSystems + Azure AI</h3><p>The magic may seem invisible to the user — but under the hood, a well-orchestrated system of AI services and low-code logic brings it all to life.</p><p>To build the Bookshelf AI prototype, we combined the best of both worlds:</p><ul><li><strong>Azure OpenAI</strong> for deep document understanding</li><li><strong>Azure Cognitive Services (OCR)</strong> for extracting text from scanned files</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*86bI_yA5d-8moEzrimfcew.png" /><figcaption>Azure Cognitive Services (OCR)</figcaption></figure><ul><li><strong>Vector indexing</strong> for similarity-based search</li><li><strong>OutSystems</strong> as the low-code backbone that ties it all together</li><li><strong>AI Models</strong> configured in OutSystems to support an agent that interacts with the GPT 4o (in this case)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nu2Z63KoMel5xMzkj1Exjg.png" /><figcaption>AI Models page in ODC</figcaption></figure><h3>Here’s how it works in practice:</h3><ul><li><strong>Document Ingestion</strong></li></ul><p>Files are uploaded or dropped into a central folder — Azure blob storage in this example.</p><ul><li><strong>Preprocessing and OCR</strong></li></ul><p>For scanned documents or images wrapped in PDFs, Azure Cognitive Services OCR extracts readable text. This step ensures that even “dumb” scans become usable by the AI.</p><ul><li><strong>Document Interpretation with GPT</strong></li></ul><p>Each document’s content is passed to an LLM (via Azure OpenAI), using a structured prompt.</p><pre>Your task is to identify and catalog the documents provided to you according to the following categories: <br>- Title<br>- Author<br>- DocumentType (classifies the document by topics and genres, even when they lack metadata or explicit <br>filenames, by intelligently analyzing its content - only 1 type is allowed)<br>- Year (select a year randomly &gt; 1920)<br>- Summary<br>- Filename<br><br>You will be returning this information using the following JSON format:<br>{<br> &quot;Title&quot;: &quot;title of the document (e.g. AI for Dummies)&quot;,<br> &quot;Author&quot;: &quot;author of the document (e.g. Joaquim dos Anzois)&quot;,<br> &quot;DocumentType&quot;: &quot;type of document based on the document (e.g. Book, Article, ...)&quot;<br> &quot;Year&quot;: &quot;Year the document was created (e.g. 2023)&quot;,<br> &quot;Summary&quot;: &quot;This is a summary of the document&quot;,<br> &quot;Filename&quot;: &quot;name of the file . extension&quot;<br>}<br><br>In the Summary, you will summarize the document with 2000 characters.<br><br>Non of the fields are mandatory, therefore if you don&#39;t know the answer to them, leave them blank.<br>It is important that you return a valid JSON and a valid JSON only.</pre><p>The AI acts like a librarian, returning a response in JSON format:</p><pre>{<br>  &quot;Title&quot;: &quot;Atomic Habits&quot;,<br>  &quot;Author&quot;: &quot;James Clear&quot;,<br>  &quot;DocumentType&quot;: &quot;Self-Help&quot;,<br>  &quot;Year&quot;: &quot;2018&quot;,<br>  &quot;Summary&quot;: &quot;A guide to building better habits and breaking bad ones...&quot;,<br>  &quot;Filename&quot;: &quot;atomic_habits.pdf&quot;<br>}</pre><ul><li><strong>Embedding for Semantic Search</strong></li></ul><p>The content is also embedded into a high-dimensional vector space, which allows it to be searched based on meaning rather than exact words. This enables queries like:</p><p><em>“Articles about decision-making biases”</em> — even if those exact words never appear in the file.</p><ul><li><strong>OutSystems + AI Models</strong></li></ul><p>On the front end, users get a clean, fast, and flexible interface built entirely in <strong>OutSystems</strong>, seamlessly integrated with the model configured in <strong>ODC AI Models</strong>. They can search <em>naturally</em>, filter results, preview document summaries, and open files — all without needing to know where anything is stored. But they can do more than search. They can <strong>talk to their data</strong>!</p><p>Thanks to AI Models, users can ask questions in plain language — like <em>“What trends appear in 2023 reports?”</em> or <em>“Summarize all files related to stress management.”.</em> The agent understands the intent, combs through the indexed content, and responds like a smart assistant who’s already read everything.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cXs7tXqozGHx1-eIzpcj_A.png" /><figcaption>Bookshelf AI — Chat screen</figcaption></figure><p>It’s not just about retrieving documents anymore.</p><p>It’s about unlocking insights — conversationally, contextually, and instantly.</p><p>This system is <strong>scalable</strong>, <strong>repeatable</strong>, and <strong>adaptable</strong>.</p><p>And while Bookshelf AI is a fictional wrapper, the underlying architecture is already solving real problems for real teams.</p><h3>⚙️ Why OutSystems Works Well Here</h3><p>Behind every intelligent experience is a lot of plumbing. File detection, data transformation, API calls, data binding, UX refinement — none of it is glamorous, but all of it matters.</p><p>This is where <strong>OutSystems</strong> shines — not just as a low-code platform, but as a <strong>high-productivity, enterprise-grade foundation</strong> for AI-infused applications.</p><h3>OutSystems plays a critical role by:</h3><ul><li><strong>Orchestrating the document ingestion pipeline</strong></li></ul><p>Detecting new files, triggering AI workflows, managing state, and storing outputs — all handled through visual logic and automated processes.</p><ul><li><strong>Integrating seamlessly with Azure AI services</strong></li></ul><p>Whether it’s calling Azure OpenAI for content understanding or Cognitive Services for OCR, these integrations are built quickly and securely via standard or custom connectors and REST APIs.</p><ul><li><strong>Delivering a rich, adaptive front-end experience</strong></li></ul><p>Customizable UI components allow you to build dynamic search interfaces, filter controls, previews, and chat-style interactions with the AI agent — all visually, without reinventing the wheel.</p><ul><li><strong>Supporting rapid iteration</strong></li></ul><p>Need to tweak how metadata is extracted? Add new document types? Change how results are ranked? OutSystems enables fast adjustments — even in live environments — without breaking the flow.</p><p>The OutSystems platform lets small teams deliver complex, AI-powered capabilities with enterprise scalability.</p><h3>🧭 Final Thoughts</h3><p>The demo may have been fictional but the problem? Very real.</p><p>The solution? Entirely achievable — right now.</p><p>What began as a white-labeled concept inspired by a customer challenge quickly evolved into something more: a blueprint for how developers and teams can use AI to <strong>unlock the value trapped inside unstructured content</strong>.</p><p>You don’t need a fleet of data scientists or a year-long transformation program. You need a starting point, the right platform, and a willingness to rethink what “search” should feel like. Start with that folder of PDFs no one wants to touch. Let AI read, understand, and organize it.</p><p>Give your users a search box that speaks their language and watch the experience go from frustrating… to intuitive.</p><p>With <strong>OutSystems</strong> as your delivery engine, and <strong>Azure AI</strong> as your intelligence layer, you’re not just building apps — you’re building interfaces to understanding.</p><p>Let’s stop searching. Let’s start finding!</p><p><strong>Note from the writer</strong></p><p><em>This article marks the end of my </em><strong><em>first exploratory cycle in AI</em></strong><em> — a journey that started with curiosity, grew through experimentation, and culminated in both a </em><strong><em>live customer implementation</em></strong><em> and a </em><strong><em>talk at OutSystems Developer Days</em></strong><em>.</em></p><p><em>But this is just the surface.</em></p><p><em>The experience taught me that AI isn’t a single solution or feature — it’s a shift in how we build, think, and deliver value. From here, the questions get bigger, the use cases more ambitious, and the possibilities even more exciting.</em></p><p><em>So while this cycle closes, the real work — and real impact — starts now.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac5441c05520" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OutSystems ODC Rest APIs: Unlocking Limitless Integration Possibilities]]></title>
            <link>https://medium.com/@neves.sousa/outsystems-odc-rest-apis-unlocking-limitless-integration-possibilities-913f875cacfd?source=rss-c1f02a8b2da6------2</link>
            <guid isPermaLink="false">https://medium.com/p/913f875cacfd</guid>
            <category><![CDATA[outsystems-odc]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[outsystems-development]]></category>
            <category><![CDATA[outsystems-mvp]]></category>
            <category><![CDATA[outsystems]]></category>
            <dc:creator><![CDATA[João Sousa]]></dc:creator>
            <pubDate>Sun, 22 Dec 2024 00:22:14 GMT</pubDate>
            <atom:updated>2024-12-22T00:22:14.025Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This article is also posted in the </em><a href="https://www.acceleratedfocus.com/post/outsystems-odc-rest-apis-unlocking-limitless-integration-possibilities"><em>Accelerated Focus Blog</em></a></p><p><a href="https://www.acceleratedfocus.com/"><em>Accelerated Focus</em></a><em>, recognized as </em><a href="https://www.acceleratedfocus.com/post/accelerated-focus-awarded-2023-outsystems-partner-of-the-year"><em>Partner of the Year 2023</em></a><em>, focuses on solving business challenges with low-code, delighting employees, and fostering partnerships with organizations looking to grow and transform because doesn’t just build apps — builds businesses.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HXINRiW28yeP-Cv52RCm2Q.png" /></figure><p>If there’s one thing that excites me as a developer, it’s the ability to push tools and platforms beyond their default limits. APIs are what make this possible. They act as the bridge that connects systems, unlocking powerful automation, seamless integrations, and giving me unparalleled control over workflows. In my experience, APIs aren’t just a technical tool — they’re the cornerstone of innovation, helping me create solutions that are both efficient and ready to adapt to whatever changes come next.</p><p>I’ve seen firsthand how APIs open doors to endless possibilities. Whether I’m streamlining complex workflows or experimenting with new integrations, APIs give me the power to break down barriers, connect systems, and transform data into actionable insights. They’ve become my go-to toolkit for crafting applications that not only work smarter but also scale effortlessly. In this guide, I’ll take you through my journey with the newly released ODC Rest APIs (<em>User and Access Management API</em> and <em>Portfolio API</em>) and show you how they can help elevate your projects to new heights.</p><h3><strong>Setting the Stage: What Makes APIs So Essential?</strong></h3><p>APIs are nothing new, but every time I work with them, I’m reminded of how transformative they can be. They’re not just a way to connect systems — they’re the backbone of automation, integration, and customization. When I use APIs, I’m not just building applications; I’m crafting interconnected ecosystems that run smarter and more efficiently.</p><p>For me, APIs stand out because they bring so much versatility to the table. Here’s what I love most about working with them:</p><p>1. <strong>Automation</strong>: They save me countless hours by automating repetitive tasks like user provisioning and deployment tracking. What used to take hours can now happen in seconds.</p><p>2. <strong>Integration</strong>: APIs let me connect external systems effortlessly, bridging the gap between tools and platforms to create seamless workflows.</p><p>3. <strong>Customization</strong>: They give me the flexibility to tailor workflows, user experiences, and backend processes to meet the unique needs of every project I take on.</p><p>With APIs, I can focus on building solutions that are not only functional but also optimized for the way I work. It’s like having a toolbox where every tool is designed to make my life easier.</p><h3><strong>Step 1: Getting Started with ODC Rest APIs</strong></h3><p>Before diving into the APIs themselves, it’s important to set up your environment correctly within the ODC portal. While it’s straightforward, skipping or misconfiguring these steps can lead to unnecessary headaches later on. Here’s how I get started:</p><h4><strong>1. Configure Your API Client</strong></h4><p>In the ODC portal, the API Client is your system’s unique identity — it’s how the platform recognizes and authenticates your application. Setting it up is a key first step:</p><ul><li><strong>Navigate to the API clients section</strong> in the ODC portal.</li><li>Click on <strong>“Create API Client”</strong> to open the setup form.</li><li><strong>Provide a name for your client</strong>: This should be something descriptive that helps you identify the application later.</li><li>(Optional) <strong>Add a description</strong>: This is useful if you have multiple clients and need a quick reference for what this one does.</li><li><strong>Set an expiration date for the client secret</strong>: By default, it’s set to expire in 90 days, but you can adjust this depending on your security policies. You can also enable email reminders to notify you before the secret expires.</li><li>The <strong>Stage selection</strong> is automatically set due to the inheritance of User management permissions. A quick reminder: users in ODC serve all stages, including Development, Test, and Production..</li><li>In the <strong>User Management</strong> section, choose the specific operations this API Client can perform.</li><li>Once everything is filled out, click <strong>“Create API Client”</strong>. The portal will generate a client secret for you, which you’ll need to securely store — this is what your application will use to authenticate requests.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s8YwCmJAL-ILJ65zuQt7Dw.png" /><figcaption>Create API client</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O0zKE4KNmQVnkXilJzn1wg.png" /><figcaption>My client credentials — Client ID and Client Secret</figcaption></figure><h4><strong>2. Master OAuth 2.0</strong></h4><p>When working with ODC Rest APIs, secure authentication is non-negotiable — and that’s where OAuth 2.0 comes into play. This protocol ensures that only authorized applications can access the APIs, safeguarding sensitive data and operations. It’s straightforward once you understand the flow, but how OAuth 2.0 Works?</p><p>To authenticate API calls, I need an <strong>access token</strong>, which I obtain by exchanging my client credentials — Client ID and Client Secret (generated in the previous step). Think of this token as a temporary key — it grants my application secure, time-limited access to the APIs. Every API request I make includes this token in the authorization header, ensuring that only authorized applications can interact with the system. Access tokens are critical for keeping interactions secure, but they also require careful management. I always make sure to:</p><ul><li>Store tokens securely to prevent unauthorized access.</li><li>Monitor token expiration and refresh them as needed to avoid interruptions.</li></ul><p>But where do I get the token from? Which URL do I need to use?</p><h4><strong>3. Understand OIDC Discovery</strong></h4><p>When working with ODC Rest APIs, secure authentication is essential and OAuth 2.0 is the protocol that facilitates this. One of the key steps in this process is understanding and using the OpenID Connect (OIDC) Discovery mechanism. This simplifies authentication by providing the necessary endpoints and metadata for interacting with the authorization server. Here’s how I approach it:</p><p><strong>Understanding the Process</strong></p><p>To access the APIs, I need to obtain an <strong>access token</strong> using my client credentials (client ID and client secret) like I mentioned before. The OIDC Discovery document simplifies this process by offering a centralized source for all relevant authentication information. Here’s the workflow I follow:</p><p>1. <strong>Obtain the Discovery Document</strong>:</p><p>I start by retrieving the OIDC Discovery document, which provides the necessary endpoints for authentication. This is done by sending a GET request to the .well-known endpoint of my ODC portal domain:</p><pre>curl -X GET &quot;https://&lt;ODC_PORTAL_DOMAIN&gt;/identity/.well-known/openid-configuration&quot; -H &quot;accept: application/json&quot;</pre><p><em>Replace &lt;ODC_PORTAL_DOMAIN&gt; with your organization’s domain.</em></p><p>2. <strong>Retrieve the Token Endpoint</strong>:</p><p>From the Discovery document, I extract the token_endpoint value. This endpoint is where I’ll send my request to obtain an access token.</p><p>3. <strong>Request the Access Token</strong>:</p><p>With the token endpoint and my client credentials, I send a POST request to fetch the access token:</p><pre>curl -X POST &quot;&lt;TOKEN_ENDPOINT&gt;&quot; -H &quot;Content-Type: application/x-www-form-urlencoded&quot; -d &quot;grant_type=client_credentials&amp;client_id=&lt;CLIENT_ID&gt;&amp;client_secret=&lt;CLIENT_SECRET&gt;&quot;</pre><p><em>Replace &lt;TOKEN_ENDPOINT&gt;, &lt;CLIENT_ID&gt;, and &lt;CLIENT_SECRET&gt; with the appropriate values.</em></p><p>If the credentials are valid, the authorization server responds with an access token:</p><pre>{<br>  &quot;access_token&quot;: &quot;ACCESS_TOKEN&quot;,<br>  &quot;expires_in&quot;: 43200,<br>  &quot;token_type&quot;: &quot;Bearer&quot;<br>}</pre><p><em>The expires_in value indicates the token’s validity period in seconds (e.g., 12 hours).</em></p><p><strong>Best Practices</strong></p><p>Managing access tokens responsibly is crucial:</p><ul><li><strong>Secure Storage</strong>: Store tokens securely to prevent unauthorized access.</li><li><strong>Monitor Expiration</strong>: Tokens are valid for 12 hours, so I always request a new token before the current one expires to maintain uninterrupted access.</li></ul><p>By following these steps and leveraging the OIDC Discovery mechanism, I establish a secure and efficient authentication flow, allowing my application to interact seamlessly with ODC Rest APIs.</p><h3><strong>Step 2: Explore the Core APIs</strong></h3><p>With the setup complete, it’s time to dive into the APIs and see what they can do. For me, mastering the core APIs is where the magic happens — they’re the tools that turn everyday tasks into seamless, automated processes. Here are the key ones I recommend starting with:</p><h4><strong>1. User and Access Management API</strong></h4><p>Managing users and roles is critical to the success of any application, and this API makes it both efficient and flexible. Here’s how I use it:</p><ul><li><strong>Automate user provisioning and deprovisioning</strong>: Adding or removing users no longer needs to be a manual process.</li><li><strong>Assign roles dynamically</strong>: With business logic driving role assignments, I can ensure users always have the right access.</li><li><strong>Enhance security</strong>: This API helps me enforce strict access controls, ensuring only the right people have access to sensitive areas of the application.</li></ul><p><a href="https://success.outsystems.com/documentation/outsystems_developer_cloud/outsystems_language_and_elements/outsystems_apis/odc_rest_apis/user_and_access_management_api/">Here</a> is the link for the OpenAPI spec.</p><h4><strong>2. Portfolio API</strong></h4><p>If you’re managing multiple applications, the Portfolio API is a must-have. Similar to the Lifetime API in OS11, in this 1st version, it provides an organized way to keep track of your application portfolio by allowing you to retrieve the information about assets and environments. More to come (I hope :D)</p><p><a href="https://success.outsystems.com/documentation/outsystems_developer_cloud/outsystems_language_and_elements/outsystems_apis/odc_rest_apis/portfolio_api/">Here</a> is the link for the OpenAPI spec.</p><h3><strong>Step 3: Respect the Boundaries</strong></h3><p>When working with APIs, it’s critical to be aware of rate limits. These limits ensure fair usage across all users and help maintain the performance of the platform. OutSystems enforces global rate limits per organization, which vary based on the API domain. Understanding these limits can help you plan your API usage and avoid hitting unnecessary roadblocks.</p><h4><strong>How Rate Limits Work</strong></h4><p>Here’s a breakdown of the current rate limits for OutSystems APIs:</p><ul><li><strong>User and Access Management</strong>: 100 requests per minute.</li><li><strong>Portfolio Management</strong>: 100 requests per minute.</li><li><strong>Bulk User Create API</strong>: Limited to 5 requests per minute.</li></ul><p>If you exceed the rate limit, the server will return a 429 Too Many Requests response, signaling that your application needs to pause and retry after some time.</p><h4><strong>Tips for Staying Within the Limits</strong></h4><p>To avoid throttling and ensure smooth operation, I use the following strategies:</p><ul><li><strong>Prioritize critical requests</strong>: I ensure high-priority operations are executed first to make the most of the allocated request limits.</li><li><strong>Batch operations</strong>: Where possible, I combine multiple actions into a single request to reduce the number of calls.</li><li><strong>Implement retry logic</strong>: If my application encounters a 429 Too Many Requests response, it automatically waits and retries the request after the cooldown period.</li></ul><h3><strong>Step 4: Secure Your Integration</strong></h3><p>APIs are incredibly powerful tools, but with that power comes great responsibility. Ensuring the security of your integrations isn’t just about protecting your data — it’s about maintaining trust and the reliability of your applications. Over time, I’ve learned that following a few key best practices goes a long way in keeping everything secure.</p><p>1. <strong>Rotate Credentials Regularly</strong>: Avoid reusing the same client secret indefinitely. Regularly updating your credentials reduces the risk of misuse, especially if a key is accidentally exposed or compromised.</p><p>2. <strong>Use Least Privilege</strong>: Only grant your API Client the permissions it absolutely needs. By limiting access to specific environments and operations, I minimize potential damage in case of an issue.</p><p>3. <strong>Monitor Access Patterns</strong>: Keep an eye out for unusual activity or unauthorized access attempts. Logging API usage and reviewing it periodically helps me catch anomalies early, ensuring I stay ahead of potential threats.</p><p>By implementing these strategies, I’ve been able to maintain secure integrations while minimizing risks.</p><h3><strong>Real-World Use Cases</strong></h3><p>APIs shine when applied to real-world challenges, and the ODC Rest APIs are no exception. Here are a few practical ways I’ve seen them transform workflows and simplify everyday tasks:</p><h4><strong>1. Onboarding Automation</strong></h4><p>The User and Access Management API is a game-changer for automating onboarding. When a new employee joins, I can instantly create their user account, assign roles dynamically, and grant them the exact permissions they need — all without manual intervention. This streamlines the onboarding process, reduces errors, and saves time for both IT teams and managers.</p><h4><strong>2. Portfolio Insights</strong></h4><p>With the Portfolio API, keeping tabs on active applications has never been easier. I use it to monitor my team’s entire application portfolio in real-time, ensuring no app falls through the cracks. Whether it’s tracking updates, categorizing applications, or generating quick overviews for stakeholders, this API keeps everything organized and accessible.</p><h4><strong>3. Dynamic Workflows</strong></h4><p>By integrating ODC APIs with third-party tools, I’ve been able to build workflows that adapt to business needs in real-time. For example, combining these APIs with automation platforms or custom scripts allows me to trigger specific actions based on predefined conditions, creating a responsive and efficient system that evolves with my projects.</p><h3><strong>A Developer’s Edge</strong></h3><p>For me, the ODC Rest APIs aren’t just tools — they’re enablers. They empower me to:</p><ul><li>Build smarter, more efficient systems with less manual effort.</li><li>Seamlessly integrate applications into the broader tech ecosystem.</li><li>Deliver solutions that are dynamic, responsive, and secure.</li></ul><p>By following the steps I’ve outlined in this guide, you’re well on your way to mastering these APIs and taking your applications to the next level. Whether it’s automating workflows, managing user access, or gaining deeper insights into your portfolio, the possibilities are endless.</p><p>So, what’s stopping you? Dive into the documentation, start experimenting, and let your creativity take flight. With the ODC Rest APIs, the only limit is your imagination.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=913f875cacfd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microsoft Clarity with OutSystems: Where Analytics Meets AI]]></title>
            <link>https://medium.com/@neves.sousa/microsoft-clarity-with-outsystems-where-analytics-meets-ai-0bd989d1722a?source=rss-c1f02a8b2da6------2</link>
            <guid isPermaLink="false">https://medium.com/p/0bd989d1722a</guid>
            <category><![CDATA[outsystems-mvp]]></category>
            <category><![CDATA[analytics]]></category>
            <category><![CDATA[outsystems-development]]></category>
            <dc:creator><![CDATA[João Sousa]]></dc:creator>
            <pubDate>Mon, 15 Apr 2024 18:17:17 GMT</pubDate>
            <atom:updated>2024-04-15T18:23:49.541Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*njZlnBvxDTONF9U-.jpg" /><figcaption>Generated image — deepai.org</figcaption></figure><p>As an OutSystems Architect, I’ve witnessed firsthand the transformative power of technology in shaping user experiences. But in today’s hyper-competitive digital landscape, understanding user behavior isn’t just a nice-to-have — it’s a strategic imperative. Enter Microsoft Clarity, our trusty compass for navigating the user experience terrain.</p><p>But wait, there’s more! Clarity isn’t alone on this quest. It now has a magical companion: Copilot. Copilot, powered by artificial intelligence, adds a dash of wizardry to Clarity’s insights. Together, they unravel mysteries, decode user interactions, and empower us to create exceptional digital realms.</p><h3>The Quest for Exceptional User Experiences</h3><p>User expectations have skyrocketed. Whether it’s a consumer app, an enterprise solution, or an e-commerce platform, users demand seamless interactions, lightning-fast load times, and intuitive interfaces. As architects, we recognize that every click, scroll, and hesitation matters. But how do we measure these interactions effectively? That’s where Microsoft Clarity steps in.</p><h3>The Business Impact: Where Magic Meets Metrics</h3><p>Beyond aesthetics and usability, user experience directly impacts business success. Here’s how:</p><ol><li><strong>Conversion Rates:</strong> A well-designed user experience translates to higher conversion rates. Whether it’s completing a purchase, signing up for a newsletter, or submitting a form, every interaction contributes to the bottom line. By integrating Clarity, we gain insights into what drives conversions and where users drop off.</li><li><strong>Retention and Loyalty:</strong> Users who enjoy a smooth experience are more likely to return. Repeat visits lead to customer loyalty, word-of-mouth referrals, and increased lifetime value. Clarity’s session recordings reveal pain points, allowing us to fine-tune our applications for maximum retention.</li><li><strong>Optimizing Features:</strong> As architects, we’re constantly enhancing features. But which ones truly resonate with users? Clarity’s heat maps pinpoint where users engage most. Armed with this knowledge, we can prioritize feature development and allocate resources wisely.</li></ol><p>In this article, we’ll explore how to seamlessly integrate Clarity into OutSystems, empower our development teams, and unravel the secrets hidden within user interactions. So, fellow architects, let’s wave our wands (or just click a few buttons), and let Clarity’s enchantment begin! 🌟🔮🚀</p><h3>2. What Is Microsoft Clarity?</h3><h3>A Closer Look</h3><ul><li><strong>Microsoft Clarity</strong> isn’t just another analytics tool; it’s a revelation for web owners and developers.</li><li>It provides granular insights into user interactions, heatmaps, session recordings, and more.</li><li>But what sets Clarity apart? Let’s explore further.</li></ul><h3>Copilot in Microsoft Clarity</h3><ul><li>Imagine a fusion of Generative AI and Clarity — this is Copilot. It’s like having a trusty sidekick that speaks the language of data.</li><li>Copilot incorporates Large Language Models (LLMs) from OpenAI (yes, the same technology behind ChatGPT and the new Bing). Together, they unravel insights from your website’s data.</li><li>Overall goal? To make analytics accessible for everyone. Clarity started by democratizing analytics with a free and open-sourced product, and now it’s democratizing the data itself.</li></ul><h3>Impact on Application Performance</h3><ul><li>As architects, we’re wary of anything that might slow down our applications. The good news? Clarity’s JavaScript is loaded asynchronously, ensuring that visitors to your site won’t experience any difference in speed or performance.</li><li><a href="https://www.bing.com/aclick?ld=e8zokNlM146vsZsSf9b_T6LTVUCUyqZVjTd9JAos51Br7WHKQSdDsX1JCBM3XPEuxl9VukxTGNdmEid-gtwiepR4mP6e5aRDOqmdYO2bstXHLHJnYFdzi1FXen7rvnBNgfSLopOMXfy3LNC_xY3fPb-leT2kxneg4VZmmyICF91neF43Q8&amp;u=aHR0cHMlM2ElMmYlMmZ3d3cuaWJtLmNvbSUyZnByb2R1Y3RzJTJmaW5zdGFuYSUyZmFwcGxpY2F0aW9uLXBlcmZvcm1hbmNlLW1vbml0b3JpbmclM2Z1dG1fY29udGVudCUzZFNSQ1dXJTI2cDElM2RTZWFyY2glMjZwNCUzZDQzNzAwMDc0NTk5Mjg5NTU5JTI2cDUlM2RwJTI2Z2NsaWQlM2Q0NmY5ZTM5M2QyNzkxNzEzZDQ1Mzg1OGY4YjAzMjFlMiUyNmdjbHNyYyUzZDNwLmRzJTI2bXNjbGtpZCUzZDQ2ZjllMzkzZDI3OTE3MTNkNDUzODU4ZjhiMDMyMWUy&amp;rlid=46f9e393d2791713d453858f8b0321e2">Clarity’s unique approach minimizes impact: it captures low-level drawing operations instead of videos or screenshots, resulting in a highly optimized experience</a><a href="https://bing.com/search?q=Microsoft+Clarity+features+and+impact+on+application+performance">1</a><a href="https://learn.microsoft.com/en-us/clarity/mobile-sdk/mobile-sdk-overview">2</a>.</li></ul><h3>Data Handling and Privacy</h3><ul><li>Concerned about data security? Clarity respects user privacy. No personally identifiable information (PII) is stored.</li><li>Microsoft ensures compliance with privacy regulations, giving peace of mind to both users and business owners.</li></ul><h3>Enriching Clarity with APIs</h3><p>Yes, there’s more! Clarity offers APIs for those hungry for deeper insights. These APIs allow you to:</p><ul><li><strong>Customize Data Collection</strong>: Tailor Clarity’s data collection to your specific needs.</li><li><strong>Integrate with Other Tools</strong>: Combine Clarity data with your existing analytics stack.</li><li><strong>Build Custom Dashboards</strong>: Create visualizations that align with your business goals.</li><li><strong>Automate Tasks</strong>: Use APIs to automate repetitive tasks, saving time and effort.</li></ul><p>Here are 2 examples of the most common scenarios.</p><p><strong>Custom Identifiers:</strong></p><ul><li>They allow you to send additional information about site visitors to Clarity. These identifiers include custom-id, custom-session-id, and custom-page-id.</li><li>Use the identify API to customize features that require specific identifiers. For instance:</li></ul><pre>window.clarity(&quot;identify&quot;, &quot;user123&quot;, &quot;session456&quot;, &quot;page789&quot;, &quot;MyFriendlyName&quot;);</pre><ul><li>These identifiers help tailor Clarity’s insights to your specific context.</li></ul><p><strong>Custom Tags:</strong></p><ul><li>Sometimes, predefined filters aren’t enough. With custom tags, you can track site-specific events or behaviors.</li><li>Use the set API to define custom tags in your JavaScript:</li></ul><pre>window.clarity(&quot;set&quot;, &quot;myCustomTag&quot;, &quot;importantFeature&quot;);</pre><ul><li>When Clarity collects data related to this tag, it appears in the Filters options, allowing you to analyze it separately.</li></ul><p>Now you just need to go to the <a href="https://clarity.microsoft.com/">Clarity website</a> and create a new project. It’s straightforward, but if you have any issues click <a href="https://learn.microsoft.com/en-us/clarity/setup-and-installation/clarity-setup">here</a>.</p><p>In summary, Clarity isn’t just a tool; it’s a strategic asset!</p><h3>3. Clarity with OutSystems: Having Fun in 5 Steps!</h3><p>As an Architect, I try to thrive on making complex integrations feel like a walk in the park. Here’s how you can integrate Clarity into your OutSystems applications:</p><ol><li>Download the Microsoft Clarity component from the Forge (<a href="https://www.outsystems.com/forge/component-overview/18487/microsoft-clarity-o11">OS 11</a> or ODC — will add the links here once they are available) or build your own</li><li>Add the web block as a dependency</li><li>Drag and drop it in the layouts of your application (to have the full coverage)</li><li>Configure it to accept the Clarity account ID of your Project</li><li>Publish and Test</li></ol><p>Peek into the browser’s developer console (yes, the mystical one). Voilà! Verify that the Clarity script is loaded without any hiccups. Test user interactions — click, scroll, and marvel at the insights unfolding.</p><p>Should be something similar to this ;)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xz_F6lhTXhS5lZLMne7mJA.png" /><figcaption>Microsoft Clarity — Dashboad</figcaption></figure><h3>The Spellbinding Result</h3><p>By integrating Clarity, you’ve just added a crystal ball to your OutSystems app. You’ll see where users linger, which buttons they adore, and where they occasionally raise an eyebrow. Armed with this knowledge, you can optimize your app’s design, enhance user satisfaction, and — dare I say — work some real magic for your business.</p><p>So, fellow architects, let’s chant the incantation: “Clarity, integrate with OutSystems!” 🌟🔮🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0bd989d1722a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Don’t leave for tomorrow, what you can do today!]]></title>
            <link>https://medium.com/@neves.sousa/dont-leave-for-tomorrow-what-you-can-do-today-bb2b27a5b972?source=rss-c1f02a8b2da6------2</link>
            <guid isPermaLink="false">https://medium.com/p/bb2b27a5b972</guid>
            <dc:creator><![CDATA[João Sousa]]></dc:creator>
            <pubDate>Fri, 23 Feb 2024 23:17:49 GMT</pubDate>
            <atom:updated>2024-02-23T23:17:49.748Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This article was originally posted in the </em><a href="https://www.acceleratedfocus.com/post/don-t-leave-for-tomorrow-what-you-can-do-today"><em>Accelerated Focus Blog</em></a></p><p><a href="https://www.acceleratedfocus.com/"><em>Accelerated Focus</em></a><em>, recently recognized as </em><a href="https://www.acceleratedfocus.com/post/accelerated-focus-awarded-2023-outsystems-partner-of-the-year"><em>Partner of the Year 2023</em></a><em>, focuses on solving business challenges with low-code, delighting employees, and fostering partnerships with organizations looking to grow and transform because doesn’t just build apps — builds businesses.</em></p><p>A practical approach to OutSystems project documentation</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jUejMq7FGFT385AZ.png" /></figure><p>In the OutSystems Developers community, many of you are, or were, somehow involved in “moving train” projects where applications were designed by some and developed by others. By the time you start(ed), most of these people aren’t in the project anymore. This shouldn’t be an issue!</p><p>In my opinion, the more exposed we are to different realities, the more we learn, but I’ll leave this topic to another article. The problem starts when we leave the project without leaving the minimum amount of documented information we would have wished to receive from others on our 1st days.</p><p>There are many reasons for that, and I am sure that by now, a couple of them have already popped into your mind. However, in the end, if there is anyone to blame is yourself because you accepted those conditions. Again, another topic for another moment :)</p><p>So, what should be the <strong>minimum amount of documentation</strong> we should create to guarantee others don’t go through the same moments of pain we went to understand the outcomes of those projects? Or, as many might say, what the hell happened there?! ;)</p><p>The bigger the OutSystems factory is, the more important it is to document what was done. Another relevant factor, for me, is the purpose of the factory since that will drive the way documentation can be created:</p><ol><li>The main purpose of my factory is to create applications/products connected around the same Line of Business. In this use case, documentation should reflect the different domains composing the applications/products.</li><li>In my factory, I will support the growth of several applications throughout the vast number of Line of Business in my organization. This use case promotes the creation of documentation that follow the segregation of the different Line of Businesses.</li></ol><p>Those who have read my past articles (Alert: the internet has much more interesting content) might notice similarities with how I structure <a href="https://link.medium.com/GeKkFxc7Spb">Teams in Lifetime</a>. It follows the same pattern, not because there is a need to authorize or limit access to the documentation but more from the perspective of who owns the documentation. The Team that owns the code also gives coherence to the overall processes.</p><p>There are different roles in a Team: Product Owner/Engagement Manager, Tech Leads, Developers, Testers, etc., but all should be responsible for producing and maintaining documentation at their level. The questions now are what to document, when to document, and where should we write our documentation?</p><p>Let’s start from the latter…</p><p><strong>WHERE</strong></p><p>Tools like Jira and Azure Dev Ops are typically used to support the Delivery Process, and all have features to host and maintain all the needed documentation. Nevertheless, there are still situations where those platforms are not within reach, and in this case, our old friends Microsoft Office and/or Google Docs can help us. There aren’t many excuses here; people just need to use them!</p><p><strong>WHAT</strong></p><p>User stories are one of the key aspects of documentation. The time invested not only ensures the correct guidance of the team members but also produces an extensive (business) knowledge base that is available for consultation once they are closed. However, the time invested in them doesn’t make them the only documentation needed. In my opinion, there are at least three more documents, from a technical perspective, that are very important to create:</p><ol><li>Release Book</li><li>Architecture Overview</li><li>Integrations Overview</li></ol><p>The <em>Release Book</em> is where you document all the needed information to support your deployment process: Site Property values, Timers 1st executions/configurations, Web Services endpoints, Mobile App builds, Security policies &amp; actions (CSPs, certificates, …), and other configurations…</p><p><em>Architecture Overview</em> is where is documented the application design. This is a live document and grows as the applications grow. I usually start with one document per business application and eventually create a master one to describe/design the macro/factory concepts that link the business application documents together.</p><p>The <em>Integrations Overview</em> document, as its name suggests, is where the integrations with the external systems and the created OutSystems APIs are documented. It follows the same approach as the Architecture Overview, where it becomes an integration-based document that evolves into a group of documents once the number of different integrations starts to be part of the delivery.</p><p><strong>WHEN</strong></p><p>As soon as possible and therefore the title of this article: <strong>Don’t leave for tomorrow what you can do today</strong>! The sooner you have your work documented, the better. It works the same way as exercise. First, you feel it as an obligation, but with time it becomes a part of you. I just hope you don’t quit! :)</p><p>In the last couple of years, I have been involved in more projects/factories that have existed for 5+years than actually having the possibility to start a project from scratch, and the pains of going through the endless number of modules without a minimum amount of documentation made me more conscient about this issue.</p><p>Teams are pressured to continuously deliver functionality over functionality, and the proper awareness of a structured delivery process is diluted over time. However, in those moments when they need to onboard new colleagues or request external help, they don’t have enough documented knowledge to support those actions making them more costly than they need to be.</p><p>This article was written based on my experience throughout the years working on different projects from different lines of business with different levels of governance maturity and different Team sizes. Other use cases might need different approaches, and different people/processes might mean different ways of working. However, I found it very helpful to have a baseline to start the conversation and the thinking process. This is just one more baseline — mine!</p><p>If you agree with this approach clap and share it! Thanks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb2b27a5b972" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lifetime — Teams set up that will make you proud]]></title>
            <link>https://medium.com/@neves.sousa/lifetime-teams-set-up-that-will-make-you-proud-4d20e562ee64?source=rss-c1f02a8b2da6------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d20e562ee64</guid>
            <dc:creator><![CDATA[João Sousa]]></dc:creator>
            <pubDate>Wed, 21 Feb 2024 18:52:32 GMT</pubDate>
            <atom:updated>2024-02-21T18:52:32.456Z</atom:updated>
            <content:encoded><![CDATA[<h3>Lifetime — Teams set up that will make you proud</h3><p><em>This article was originally posted in the </em><a href="https://www.acceleratedfocus.com/post/lifetime-a-teams-setup-that-will-make-you-proud"><em>Accelerated Focus Blog</em></a><em>.</em></p><p><a href="https://www.acceleratedfocus.com/"><em>Accelerated Focus</em></a><em>, recently recognized as </em><a href="https://www.acceleratedfocus.com/post/accelerated-focus-awarded-2023-outsystems-partner-of-the-year"><em>OutSystems Partner of the Year 2023</em></a><em>, focuses on solving business challenges with low-code, delighting employees, and fostering partnerships with organizations looking to grow and transform because doesn’t just build apps — builds businesses.</em></p><p>Leverage teams to effectively govern your OutSystems factory.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*E5o7waNJh8eCiHVP.png" /></figure><p>In the last article I wrote, <a href="https://medium.com/@neves.sousa/lifetime-create-a-governance-model-that-will-make-you-proud-81885a457e7a">Lifetime — Create a Governance Model that will make you proud</a>, the main idea was to create awareness around the Governance topic and how to enhance the out-of-the-box model that OutSystems provides in Lifetime. I have leveraged the experience of setting up these models and shared a small, but still more complete baseline of roles that you can use to govern an OutSystems factory.</p><p>All these roles alone are not enough to govern your factory, but a big step in doing it! The next one to pursue is to <a href="https://success.outsystems.com/Documentation/11/Managing_the_Applications_Lifecycle/Manage_IT_Users/Create_an_IT_Team">create Lifetime Teams</a> to organize your Lifetime Applications. There are many ways of doing it and clearly depends on what you are going to build. However, there are a few Teams that will always be present:</p><p><strong>Supported OutSystems Assets</strong></p><p>When OutSystems provides a new Development environment (e.g. when a new license is bought), it already has installed a significant number of applications. These applications are OutSystems UI and its templates, OutSystems Maps, OutSystems Charts, Users, System Components, Platform Extensibility, and the App Feedback.</p><p>Another good example of applications that can be added to this Team, which nowadays is frequently seen in OutSystems factories, is the Architecture Dashboard (Arch Dash) probe applications. I will leave <a href="https://success.outsystems.com/Documentation/11/Managing_the_Applications_Lifecycle/Manage_technical_debt/?utm_source=ost-outsystems%20tools&amp;utm_medium=ost-architecturedashboard&amp;utm_campaign=ost-docrouter&amp;utm_content=ost-helpid-30244&amp;utm_term=ost-contextualhelp">Arch Dash</a> (OutSystems technical debt monitoring tool) eventually for another article, but these applications are only installed in the OutSystems environment that is being monitored by it.</p><p><strong>Unsupported OutSystems Assets</strong></p><p>All the assets that are downloaded from the OutSystems Forge, and are not supported by OutSystems but still land under the responsibility of the factory where they are installed. In some situations, you might even want to segregate this Team by creating a new one just for the mobile plugins. There are businesses, due to their criticality, that have internal processes to verify the plugin’s code, before making them available to the developers.</p><p><strong>PoC’s, Sandboxes, and Demos</strong></p><p>Throughout the projects, it is common to test concepts and validate assumptions and for that, developers create sandboxes applications. Also, it is common for the OutSystems Forge Assets to have demo modules that most of the time come in the same Lifetime application and since they shouldn’t be deployed in production, need to be moved to a different application. Proof of Concept apps is also another type of application that can be added to this Team.</p><p><strong>Themes and Style Guides</strong></p><p>Depending on the size of the factory, the maintenance of Themes and Style Guides applications is owned by a subset of developers. The best way to enforce those restrictions is by creating a Team in Lifetime and adding those applications to it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hxAwvvJ9jvA25Ml42iVmhg.png" /><figcaption>Lifetime Teams list page</figcaption></figure><p>Now that you created the minimum number of Lifetime Teams and added the right applications it is time to give the proper access to your developers. In the last article, I suggested a baseline of permissions according to the roles that commonly work in the factories, and by now all your Lifetime users should have the default role set. The last step of this process is to assign those users to the right Team with the right role, depending on the permissions they will have on each Team.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8S83txBlaPYYeVj0rrS8GQ.png" /><figcaption>Supported OutSystems Assets Team</figcaption></figure><p>Once all this is in place you close the loop on the Governance model.</p><p>Every time a new application needs to be created should be analyzed to which Team should be added. In case of a new concept and a new Team should be created. Once the Team is in place users can be assigned and with the right role.</p><p>This article was written based on my experience throughout the years working on different projects from different lines of business with different levels of governance maturity and different Team sizes. Different use cases might need different approaches and different people/processes might mean different ways of working, however, I found it very helpful to have a baseline to start the conversation and/or the thinking process. This is just one more baseline — mine!</p><p>If you agree with this approach clap and share it! Thanks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d20e562ee64" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lifetime — Create a Governance Model that will make you proud]]></title>
            <link>https://medium.com/@neves.sousa/lifetime-create-a-governance-model-that-will-make-you-proud-81885a457e7a?source=rss-c1f02a8b2da6------2</link>
            <guid isPermaLink="false">https://medium.com/p/81885a457e7a</guid>
            <category><![CDATA[outsystems]]></category>
            <category><![CDATA[governance]]></category>
            <category><![CDATA[authorization]]></category>
            <category><![CDATA[lifetime]]></category>
            <category><![CDATA[outsystems-development]]></category>
            <dc:creator><![CDATA[João Sousa]]></dc:creator>
            <pubDate>Tue, 25 Jan 2022 09:24:05 GMT</pubDate>
            <atom:updated>2022-01-27T08:31:37.514Z</atom:updated>
            <content:encoded><![CDATA[<h3>Lifetime — Create a Governance Model that will make you proud</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*1sH94j2qSjtnIIn3.png" /></figure><p>Having a Governance Model, as simple as it can be, to manage an OutSystems Factory it is always better than not having any. This means there is already a certain concern and awareness for the topic. It is the criticality of the solutions delivered that makes this topic more or less relevant when setting up and managing an OutSystems factory.</p><p>There is an example I usually like to give, during the interactions I have with customers, to create the so much needed awareness for this topic: imagine the following situation where one of your developers decides (with the best intentions) to update a component from the OutSystems Forge without understanding if that new version is compatible with the applications that consume it, just because he has the right set of permissions. With the fast pace of delivery and without the proper authorization policies, this new version can go behind the curtains from development to production in a glimpse and create a substantial impact. This is just a small example why is important to have a Governance Model in place.</p><p>I truly believe that situations like the previous one happen fully due to the lack of knowledge or unawareness of the impact of the action. It is also true that if users are not allowed to perform certain actions, they shouldn’t have access to certain functionalities, however we live in a world with different realities and with different levels of governance maturity. The best way to mitigate these situations is by taking the most of those use cases and create that awareness, share that knowledge, with the expectation it will promote better actions in the future!</p><p>So let’s start!</p><p><a href="https://success.outsystems.com/Documentation/11/Managing_the_Applications_Lifecycle/Manage_Your_OutSystems_Infrastructure">Lifetime is the OutSystems Application</a> that allows you to manage your OutSystems infrastructure. This tool helps you to manage the application lifecycle, from development to production and supports the creation of a Governance Model that can make you proud.</p><p>There are 3 basic concepts that are relevant when we want to create a Governance Model in our factory with Lifetime. It is the combination of these concepts that will set what each user is allowed to see or do.</p><ol><li>Applications</li><li>Roles</li><li>Teams</li></ol><p>From a Lifetime perspective, Applications work as a “folder structure”, that can hold modules and extensions and, be connected with Roles through Teams. Roles are set of permissions, assigned to users, that define the operations they are allowed to do across all environments and applications.</p><p>Throughout the applicability of Governance Policies in Lifetime, Teams can be created to relate the different Applications with the Users (with a proper Role). This allows a better control of who-sees-does-what.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/964/1*4hjNYKNRO3fvsSUf3SAcVw.png" /><figcaption>Roles definition page in Lifetime [1]</figcaption></figure><p>Despite Lifetime allowing the possibility of assigning Users directly to Applications, in my opinion, that is the moment when we might need to revisit the authorization model that supports all the Governance.</p><p>Now that we went through the introduction of the concepts, let me give you my version of that Governance Model that will make you proud.</p><p>Lifetime provides out-of-the-box 2 Roles: Administrator and Developer. This allows the minimal set of permissions needed to have differentiation between these 2 roles and allowing you to start working with the platform.</p><p>There are several approaches to extend this initial setup and I cannot say which one is better. However, what I can say is that depending on the way we want to organize our factory, there are approaches that produce better results then others. Depending on the purpose of the factory, we can use the following to guide us on the selection of the approach to adopt:</p><ol><li>The main purpose of my factory is to create applications/products connected around the same Line of Business. In this use case, Teams should reflect the different Domains that will compose the applications/products.</li><li>In my factory I will support the growth of several applications throughout the vast number of Line of Business existing in my organization. This use case promotes the creation of Teams that follow the segregation of the different Line of Businesses.</li></ol><p>In both scenarios, Applications and Teams need to respect the principals of independency between them, in order to leverage growth and promote an healthy Release Management.</p><p>When assigning a User to the right Team, it is important to scope the action of that User and for that, you can use the following authorization matrix as a baseline:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/778/1*cS4Rjb-aGZvlSdMNzPnhqw.png" /><figcaption>Authorization matrix for Roles in Lifetime</figcaption></figure><p>*Default Role should be given to all users upon creation with the exceptions of the Architect and Factory Manager. In more complex situations where there is the need to scope the action of the different roles per application the scope of the Default Role needs to be adapted to fulfill that reality.</p><p>The key take away is that the governance path to follow depends on the type of solutions you are going to support. Nevertheless there is always a group of applications we have to govern and will be present independently of your model. For those I advise the creation of certain Teams and assign only the needed users with the needed role to each of them:</p><ol><li>Supported OutSystems Assets</li><li>Unsupported OutSystems Assets</li><li>Themes and Style guides</li><li>PoC’s, Sandboxes and Demos</li></ol><p>The situation I described in the beginning can be easily avoided, by following this approach :)</p><p>This article was written based on my experience throughout the years working in different projects from different lines of business with different levels of governance maturity and different Teams sizes. Different use cases might need different approaches and different people/processes might mean different ways of working, however, I found very helpful to have a baseline to start the conversation and/or the thinking process. This is just one more baseline — mine!</p><p>If you agree with this approach clap and share it! Thanks.</p><p>[1] <a href="https://success.outsystems.com/Documentation/11/Managing_the_Applications_Lifecycle/Manage_Your_OutSystems_Infrastructure">OutSystems Lifetime Documentation</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=81885a457e7a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OutSystems NextStep 2020]]></title>
            <link>https://blog.product-league.com/outsystems-nextstep-2020-fb9756c1ec39?source=rss-c1f02a8b2da6------2</link>
            <guid isPermaLink="false">https://medium.com/p/fb9756c1ec39</guid>
            <category><![CDATA[outsystems]]></category>
            <category><![CDATA[outsystemsnextstep]]></category>
            <dc:creator><![CDATA[João Sousa]]></dc:creator>
            <pubDate>Wed, 16 Sep 2020 14:44:22 GMT</pubDate>
            <atom:updated>2020-09-17T09:21:38.580Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>NextStep 2020 Post-event blog</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*v-i_I9FSsyZkYUTqZY6tmA.png" /></figure><p>Through the years NextStep has been THE event the entire OutSystems community craves for with high expectations. This is the moment where OutSystems shares with the world, the evolution, and roadmap of the product, including all the new and exciting add-ons for the product. It’s the moment to get together with <em>old </em>friends, meet new people, share knowledge and experiences.</p><p>In a difficult time like the one the world is going through right now, OutSystems decided (and very well in my own perspective) not to cancel the yearly event but to make it a fully digital one!</p><p>I’m always looking forward to finding out the challenges and achievements of the community during the past year. This year we had to do all this but online. Nevertheless, the event was still organized on the level we are used to from OutSystems.</p><p>The event was split into 3 time zones: Asia Pacific, Europe, Middle East, and Africa, and the Americas. On a continuous cycle, all attendees were able to jump through all the sessions, and at the end of the day, all sessions became available for everyone to see, so no pressure, you will be able to catch them all :)</p><p>Didn’t mention this before, but all this great content in this year’s special online edition came for free with none of the usual tickets required!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tAa2v8w448bMEQ4mNxOiTg.png" /></figure><p>One of the most anticipated sessions of NextStep is the keynote. We got used to having Paulo Rosado showing us what we could expect from the product and the OutSystems teams in the following months. In this year&#39;s announcements, the strategy focussed on tooling to support the Professional Developers (aka Citizen Developers) and OutSystems created a <strong>suite of builders</strong>: accelerators on top of the OutSystems platform that will give even more speed to the process of delivery.</p><p>Also, <strong>prototyping </strong>is now more connected with the delivery since the outcome is actually OutSystems applications (code) following the best Architecture guidelines and development principles. Currently, there isn’t the possibility to push back from Service Studio into the builder and this might create some challenges organizing the operation. For sure is on the road map as a next step :)</p><p>Let me tell you that the one builder that is creating more expectations, is the <strong>Integration Builder</strong>.Removing the hurdle of integration from projects is definitely one of the items on the top of my list. Also, another builder I have my eyes on is the Machine Learning Builder. How cool is it to have a Low-Code approach to build, train, deploy, integrate, monitor, and evolve custom models for our applications? Already having goosebumps just by writing this..!</p><p>Another great announcement was the <strong>Cross-Platform Service Studio</strong>. With native experience for Mac and Windows, OutSystems refreshed the look &amp; feel of our day-to-day tool. Can’t wait to put my hands and eyes on it!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YJgHXHrx6o52v_VdVpUkAw.png" /></figure><p>On top of all this amazing content available for free, there was the <strong>OutSystems Lounge area</strong> where everyone could talk and meet with the experts. If you had that tricky question that you were aiming to get an answer for, you could just join one of the booths and fire it away. For sure everyone there was more than willing to help you.</p><p>Another interesting part of this virtual platform of the OutSystems event was the <strong>PlayArea</strong>. There was a cool trivia to test your knowledge on OutSystems. Don’t forget to post your results on social media with the #nxStep!</p><p>As part of the OutSystems community, I hope everyone who attended learned new things about the platform, connected with awesome people, and shared some of their experiences. We at Product League hope to see you soon again.</p><p>Really hope you guys had a great event.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fb9756c1ec39" width="1" height="1" alt=""><hr><p><a href="https://blog.product-league.com/outsystems-nextstep-2020-fb9756c1ec39">OutSystems NextStep 2020</a> was originally published in <a href="https://blog.product-league.com/">ProductLeague</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>