<?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 Bo Motlagh on Medium]]></title>
        <description><![CDATA[Stories by Bo Motlagh on Medium]]></description>
        <link>https://medium.com/@bomotlagh?source=rss-c3402d77a1be------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*8pB96f82rU_2jTT6Gk7tMw.jpeg</url>
            <title>Stories by Bo Motlagh on Medium</title>
            <link>https://medium.com/@bomotlagh?source=rss-c3402d77a1be------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 14:52:21 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@bomotlagh/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[Startups Should Capitalize on Their Edge Over Larger Corporations]]></title>
            <link>https://bomotlagh.medium.com/startups-should-capitalize-on-their-edge-over-larger-corporations-28f718e6f071?source=rss-c3402d77a1be------2</link>
            <guid isPermaLink="false">https://medium.com/p/28f718e6f071</guid>
            <category><![CDATA[organizational-culture]]></category>
            <category><![CDATA[startupş]]></category>
            <category><![CDATA[organizational-structures]]></category>
            <category><![CDATA[sdlc-methodologies]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Bo Motlagh]]></dc:creator>
            <pubDate>Tue, 18 Apr 2023 15:18:13 GMT</pubDate>
            <atom:updated>2023-04-18T15:18:13.391Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/746/0*5jnbZvX6ojG6GDip" /><figcaption>Source: <a href="https://www.iberdrola.com/talent/start-ups">https://www.iberdrola.com/talent/start-ups</a></figcaption></figure><p>In the ever-evolving business landscape, startups have a unique advantage over larger enterprises in their ability to rapidly develop market-ready features and technologies. Sometimes, startup founders or investors with corporate experience mistakenly believe that they should replicate the structure of larger organizations to be successful because they see them as guide posts for their own journey. In this blog post, I will discuss the benefits of startups embracing their agility and flexibility, and why attempting to mimic the structure of larger organizations can lead to a loss of their competitive edge.</p><h4>The Nimbleness Factor</h4><ol><li><strong>Swift Decision-Making:</strong> Startups, with their fewer layers of management, have the ability to make decisions at a much faster pace than their larger counterparts. This nimbleness enables them to pivot rapidly and respond effectively to changes in the market.</li><li><strong>Rapid Innovation: </strong>Leaner teams within startups enable the development of new products and features more swiftly. Fewer people in the development process means less red tape, leading to faster implementation of ideas and a shorter time to market.</li><li><strong>Cohesive Teamwork:</strong> In a startup environment, team members often wear multiple hats and work closely together. This collaboration fosters communication and teamwork, which in turn leads to better problem-solving and more efficient processes.</li><li><strong>Adaptability:</strong> Startups are more adaptable to changes in the market, technology, or customer needs. With fewer resources tied up in fixed assets or established processes, startups can pivot more easily and adapt their strategy as needed.</li></ol><h4>The Perils of Emulating Larger Enterprises</h4><ol><li><strong>Loss of Nimbleness: </strong>By trying to replicate the structure of larger enterprises, startups risk losing their agility. The very thing that gave them a competitive advantage in the first place is diminished when they add layers of management and departments that slow down decision-making and innovation.</li><li><strong>Stifling Innovation:</strong> Introducing bureaucracy and additional layers of management can stifle innovation. It can lead to slower decision-making, longer development cycles, and a reduced ability to respond to market changes.</li><li><strong>Increased Overhead Costs:</strong> Attempting to mimic the structure of larger enterprises may also lead to increased overhead costs. Hiring more people and creating additional departments can lead to higher expenses, which can be detrimental to a startup’s limited budget.</li><li><strong>Loss of Company Culture:</strong> As startups grow and add more layers of management, they risk losing the unique company culture that contributed to their initial success. The collaborative, fast-paced environment that is typical of startups can be diluted as the organization becomes more structured and hierarchical.</li></ol><p>Startups should embrace their agility and flexibility as competitive advantages rather than attempting to mimic the structure of larger enterprises. By maintaining a lean team and avoiding unnecessary bureaucracy, startups can maintain their edge in innovation, decision-making, and adaptability. As startups grow, it’s essential to strike a balance between implementing necessary structure and maintaining the agility that has been the driving force behind their success. Capitalizing on their competitive advantage will enable startups to continue disrupting the market and stay ahead of their larger competitors.</p><p>Have a different opinion? Comment below or reach out on social media. I’d love to hear from you.</p><p><em>Disclaimer: This post was written in part with the assistance of ChatGPT.</em></p><p>If you’re interested to learn about the United Effects startup journey, check us out at <a href="https://unitedeffects.com/">unitedeffects.com</a> and contact us to chat!</p><p>Follow us on <a href="https://twitter.com/ueffectsLLC">Twitter</a>, <a href="https://www.linkedin.com/company/unitedeffects/">LinkedIn</a> and <a href="https://blog.unitedeffects.com/">Medium</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=28f718e6f071" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[NATS.io Programmatic NKeys and JWTs with Node]]></title>
            <link>https://bomotlagh.medium.com/nats-io-programmatic-nkeys-and-jwts-with-node-185392b02530?source=rss-c3402d77a1be------2</link>
            <guid isPermaLink="false">https://medium.com/p/185392b02530</guid>
            <category><![CDATA[streaming]]></category>
            <category><![CDATA[jetstream]]></category>
            <category><![CDATA[queuing]]></category>
            <category><![CDATA[nats-streaming]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Bo Motlagh]]></dc:creator>
            <pubDate>Sun, 31 Jul 2022 20:03:44 GMT</pubDate>
            <atom:updated>2022-08-01T13:50:48.619Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ULkysV4agsiOonDK.png" /></figure><p>I’ve spent the last few weeks exploring <a href="https://nats.io/">NATS.io</a> and <a href="https://docs.nats.io/nats-concepts/jetstream">JetStream</a> and I’m very impressed. I’m actually a little confused how I didn’t know about JetStream sooner… it’s a great achievement and the folks working on it should be very proud. In fact, its forcing us to rethink some technology decisions at <a href="http://unitedeffects.com/">United Effects</a>… but we’ll get into that another time.</p><p>NATS is built on Go, which is just awesome. That said, my go-to language to learn a new tech interface from is Node. It’s just faster for me personally and I’m much more experienced with it. It was great to see that most of the documentation provided by NATS also has node client and configuration examples, or is simple enough to easily derive a Node version from the provided Go examples.</p><p>One concept that I did find a little challenging to understand was programmatically managing Accounts (a NATS tenant to isolate data) and Users in a configured instance or cluster. The <a href="https://natsbyexample.com/examples/auth/nkeys-jwts/go/">Nats By Example site</a> got me started with some ideas, but lacked an E2E example. I eventually figured it out (or something that works anyway) and I figured that I’d document my approach based on their example in Node, just in case there’s anyone else like me out there. Here’s how I got it working:</p><h3>Step 1</h3><p>First thing you need to do is get NATS working locally. <a href="https://docs.nats.io/running-a-nats-service/introduction/installation">There are a few options for install available</a>, but my preference was to launch it using <a href="https://docs.nats.io/running-a-nats-service/nats_docker">docker</a>. Here’s an approach that worked well for me:</p><ul><li>I created a directory to manage a docker mounted volume</li><li>I created a docker-compose.yml that allowed me to pull the image, expose the ports, mount the local directory as a volume for configurations, and send command options like “-js” or “-c /yourconfig.conf” to the image.</li><li>I created a local directory for NATS to manage JWTs</li><li>I used a very simple nats.conf file in the locally mounted volume to kick it off</li></ul><h4>Structure</h4><p>&gt;local-directory/<br>&gt;&gt;jwt/<br>&gt;&gt;nats.conf<br>&gt;&gt;docker-compose.yml</p><h4>Docker-compose</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/614/1*SYRYbghWt-gq7lryXlVdpQ.png" /></figure><h4>nats.conf</h4><p>NOTE: This will launch NATS, but we haven’t initialized Operator and System accounts yet so its not usable. Notice that I’ve enabled JetStream.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hjUcJyyPt9seOkng5tysHw.png" /></figure><h3>Step 2</h3><p><a href="https://docs.nats.io/using-nats/nats-tools/nsc/basics#creating-an-operator-account-and-user">We need to initiate a usable configuration file that gives us an Operator and System Account.</a> In a multi-tenant setup like we are building, a system account is needed to interact with $SYS subjects which control things like Accounts in NATS. An operator account is the highest level of authority and among other things, must sign all JWTs representing the new accounts we create (BTW — if you’re an expert on this stuff, feel free to comment with corrections!).</p><p>The easiest way to do this I found is to use the NSC tool and simply run the “nsc init” command. You can install and read about the NSC tool here: <a href="https://github.com/nats-io/nsc">https://github.com/nats-io/nsc</a></p><p>Run the “nsc init” command and follow the instructions to initialize an operator, an account, and a user.</p><p>Export the resulting configuration using:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/994/1*TncFJa09ztQ5yJcc0tlPjQ.png" /></figure><p>Delete the original “nats.conf” and rename this new one to replace the original. It will look something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DFDJhP84yfViCcvRDdzUog.png" /></figure><h3>Step 3</h3><p>You’ll need the nKey seeds. I’ll save the explainer on nKeys since the team at <a href="https://synadia.com/">Synadia</a> and <a href="https://nats.io/">NATS</a> do a great job, but you can check out the details here:</p><ul><li><a href="https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_intro/nkey_auth">https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_intro/nkey_auth</a></li></ul><p>You can retrieve the public keys and seeds from the operator, account, and user you just created using the following commands (the entity name is optionally randomly generated):</p><p><strong>IMPORTANT: SEEDS ARE SECRETS.</strong> Do not share them. The seeds below are for a local test environment on my machine and will never be available outside of that context.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ri3pgS0qOEV8Qtq_orPTBw.png" /></figure><p>Hold on to these.</p><h3>Step 4</h3><p>Grab the System Account User JWT that was generated by NSC. You should be able to find this in the location where NSC is storing its credentials files. There’s probably a simpler way, but that’s how I did it. You can inspect the claims of your JWT just by using jwt.io as one approach.</p><h3>Step 5</h3><p>Spin up the docker-compose and let’s programatically add an account and create a user! Just type “docker-compose up” in the local directory we created in step 1.</p><p>In any other directory, initiate a node project and install the following packages via yarn or npm:</p><ul><li>yarn add nats-jwt</li><li>yarn add nkeys.js</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/810/1*116xhlhbAKvfjdDEc1hrpw.png" /></figure><h4>Gist here</h4><p><a href="https://gist.github.com/theBoEffect/ccdfe18cff5ec7876c784a3c7a45d307">https://gist.github.com/theBoEffect/ccdfe18cff5ec7876c784a3c7a45d307</a></p><h4>Results from the node above</h4><p><strong>IMPORTANT: If you’ve configured NATS to use JWTs as Bearer tokens, they should not be shared a</strong>nd as a best practice, when generated, they should have an expiration. Otherwise they can be considered a public document. (thank you <a href="https://medium.com/u/b2df624df06f">Alberto Ricart</a> for the correction)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mkkahyQNxPhWxZthcohEog.png" /></figure><h3>Conclusion</h3><p>You’ll know this worked because there will be no authorization errors and if you look in your /jwt directory, you’ll see a new Account JWT file.</p><h3>Compulsory Plug</h3><p>At <a href="http://unitedeffects.com/">United Effects</a> we regularly explore new technologies like <a href="http://nats.io/">NATS</a> as we try to make our Core EOS platform the best possible solution for product integration and market acceleration.</p><p>Follow us on <a href="https://twitter.com/ueffectsLLC">Twitter</a>, <a href="https://www.linkedin.com/company/unitedeffects/">LinkedIn</a> and <a href="https://blog.unitedeffects.com/">Medium</a> and if you need help with anything related to Core EOS, do not hesitate to reach out to <a href="/service/mailto:help@unitedeffects.com">help@unitedeffects.com</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=185392b02530" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Core EOS is built for Edtech Auth]]></title>
            <link>https://bomotlagh.medium.com/core-eos-is-built-for-edtech-auth-2476f47d3078?source=rss-c3402d77a1be------2</link>
            <guid isPermaLink="false">https://medium.com/p/2476f47d3078</guid>
            <category><![CDATA[edtech-auth]]></category>
            <category><![CDATA[education-technology]]></category>
            <category><![CDATA[sso]]></category>
            <category><![CDATA[authorization]]></category>
            <category><![CDATA[identity-management]]></category>
            <dc:creator><![CDATA[Bo Motlagh]]></dc:creator>
            <pubDate>Sun, 31 Jul 2022 17:38:26 GMT</pubDate>
            <atom:updated>2022-07-31T17:54:44.864Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZG3OwRFd6ZAQWHE-.png" /><figcaption>Visual representation of the features of United Effects Core EOS</figcaption></figure><p>The global education technology market is a fast growing and extremely interesting $85 Billion dollar industry that is quickly evolving. There are a lot of facets to this industry that the larger market is still trying to understand or categorize. There are more obvious areas such as the K12 Software space currently worth $25 Billion. But there are less obvious areas such e-learning, which can be anything from remote education software in corporate settings to uplift employee skills, to the now globally ubiquitous constant of remote primary education thanks to the impact of Covid. Add to this mix higher education focused software providers, human capital management solutions, ERPs, and more and you have quite a dynamic and diverse set of players all competing in unexpected ways.</p><p>One clear indication of this unexpected evolution is through the sheer volume of M&amp;A activity. At <a href="http://unitedeffects.com/">United Effects</a>, our initial research into this area indicated that from 2020 to Q1/2022 there were nearly 600 M&amp;A deals. <a href="https://unitedeffects.com/industries/education-technology">Right now, there is a big trend for well-funded mid-sized edtech companies to begin a massive acquisition strategy toward fast-paced growth</a>.</p><p>It&#39;s a lucrative growth strategy when it works, though it’s hard to make work. At <a href="http://unitedeffects.com/">United Effects</a>, we have first-hand experience with the associated challenges. Three of our founding team were part of a highly successful edtech company that followed this exact same strategy, rapidly growing before achieving a billion dollar unicorn acquisition in 2016. To be clear, this didn’t stop that company’s growth trajectory and they continued acquiring about 5 or more companies per year afterwards.</p><p>As I said, <a href="https://unitedeffects.com/solutions/integrate-your-mergers-and-acquisitions">there are many technical challenges in the wholesale continuous integration of a never ending stream of acquisitions</a>. But one of the first and most important is the challenges of authentication and authorization. I personally have had to solve this problem several times at a few different companies and I can tell you that the most expensive and interesting challenge came from the edtech example I mentioned.</p><p>Let me paint a picture:</p><ul><li>Thousands of customers (districts or entities), each of whom may want their own federated SSO options and self-service tooling</li><li>Thousands of district or corporate administrators needing specialized access to add or remove employees or students</li><li>Millions of users comprised of students, employees, and other personas</li><li>Multiple new products with unique pools of users that may overlap email addresses with other products, all of which need to be merged</li><li>A hybrid approach to self-registered b2c apps and administered b2b apps</li><li>The paradox that your customers express a desire to manage all aspects of the users they manage while your users demand self-service and control over their personal information</li><li>The need to account for a consortium or franchise model for resellers of your software</li><li>Disjointed permissions/access models that now need to be merged and simplified so your customers don’t have to define the same role over and over and over just because you convinced them to buy more solutions</li></ul><p>Does any of this sound familiar?</p><p>My team and I have had to design a solution with these requirements in mind before at the company I mentioned. At that time, I did what every reader of this post probably would suggest, and reached out to the big names in Identity Management. One of the biggest (no need to name them), was my goto at the time. This company has a fantastically documented SSO solution that seemed like a no-brainer. They were also significantly less expensive than their nearest competitor, a company that would go on to acquire them some years later.</p><p>We started a POC and were annoyed to realize that at the end of the day, their platform was simply not designed for this digital transformation style, technology enablement, common single experience platform solution that we were building for our customers. They could handle the engine of OpenID Connect based integration with federation to a number of other solutions along with social logins, but they were not optimized to solve the other issues on our list. Instead, we were going to have to design a broad development effort around their product to solve the problem.</p><p>As an aside, at my next company 5 years later (2021), I assumed they would have made strides that would let me reduce the effort and reached out again. They had not.</p><p>So there we were, with a plan that was going to take roughly 18-24 months to implement (executives are already freaked out), and now we needed a quote for the central element of our solution.</p><p><strong>Millions</strong>. It was going to be <strong>millions per year</strong>. Out of respect for the company and because if you really want you can figure out who it was, I won’t say how many millions. <strong>But millions of dollars a year to this provider, plus millions more in dev, just to START solving this problem</strong>.</p><p>I knew right then and there that I could do this better. And, when I founded United Effects, my team and I did. We built the solution we wished we had back then.</p><p><strong>Any of the huge number of SSO providers can give you login and simple roles. At United Effects, we differ from ALL of these companies, include the big names like Auth0, Okta, ForgeRock, Ping, Stytch, and others, in one simple way:</strong></p><blockquote>We aren’t just solving login and access, we’re helping you integrate your edtech solutions at a reasonable price with a deep understanding of your specific challenges and industry needs.</blockquote><p><strong>Our solution Core EOS is built for Edtech Auth.</strong></p><p>You can find out more at <a href="http://unitedeffects.com/">unitedeffects.com</a> and when you’re ready, let us show you how this works so you can see it for yourself: <a href="http://calendly.com/ue-bo/show-me-core">Book a Demo</a></p><p>Follow us on <a href="https://twitter.com/ueffectsLLC">Twitter</a>, <a href="https://www.linkedin.com/company/unitedeffects/">LinkedIn</a> and <a href="https://blog.unitedeffects.com/">Medium</a> and if you need help with anything related to Core EOS, do not hesitate to reach out to <a href="/service/mailto:help@unitedeffects.com">help@unitedeffects.com</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2476f47d3078" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Core EOS Security With AWS API Gateway]]></title>
            <link>https://bomotlagh.medium.com/core-eos-security-with-aws-api-gateway-22f6412f4218?source=rss-c3402d77a1be------2</link>
            <guid isPermaLink="false">https://medium.com/p/22f6412f4218</guid>
            <category><![CDATA[lambda-authorizer]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[coreeos]]></category>
            <category><![CDATA[oidc]]></category>
            <category><![CDATA[aws-api-gateway]]></category>
            <dc:creator><![CDATA[Bo Motlagh]]></dc:creator>
            <pubDate>Sun, 22 May 2022 20:46:38 GMT</pubDate>
            <atom:updated>2022-05-22T20:46:38.399Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/869/1*Zt8F9dxnk0NPNajlzZuIuQ.png" /></figure><p>Did you know you can use Core EOS to authorize all incoming requests to AWS Gateway before the request is routed to your internal services? In this step-by-step guide, we’ll provide you the <a href="https://github.com/UnitedEffects/core-eos-oidc-authorizer">Authorizer</a> itself so you can download the code, configure Core EOS, configure your Custom Authorizer, and deploy to AWS. Let’s get started:</p><h4>Step 1</h4><p>For this demonstration, we are going to generate Client Credential access tokens because it’s an easy way to create test tokens. The process will work with any access token though.</p><p>To create the tokens, lets create or pick a Product with an API service in Core EOS. All you need to do is click “create new service” in the Product, choose type API, and add “client_credentials” as the grant type. Click to add at the bottom.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DU2wI7KzvYFHVbGYSmFe0A.png" /></figure><p>This will create a service with the “Example Authorizer” Product, with an ID and Secret. Save them both:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/844/1*yGWJtYqBFaggrrt-jbPGgQ.png" /></figure><h4>Step 2</h4><p>Also, grab your Platform Auth Group ID from the settings window and save it:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ajwRjC5p7bR5N3RHktEEww.png" /></figure><h4>Step 3</h4><p>Clone the Core EOS Authorizer project. Its written in Javascript and is MIT open source:</p><p><a href="https://github.com/UnitedEffects/core-eos-oidc-authorizer">GitHub - UnitedEffects/core-eos-oidc-authorizer: AWS Gateway Authorizer designed to work with Core EOS OIDC solution</a></p><h4>Step 4</h4><p>Create a copy of the directory “./.env_sample/” at “./.env/” as depicted, and change the name of “env.dev.json” to an appropriate environment name configuration for deployment such as “env.qa.json” in the example. Update the JSON properties appropriately, including the client ID and Secret from step 1, the Auth Group ID from step 2, and the URL to your platform instance for JWKS_URI and CORE_URI.</p><ul><li>Typically CORE_URI will either be <a href="https://auth.unitedeffects.com/">https://auth.unitedeffects.com</a> or, if you have a custom domain, whatever you’ve set for the OIDC custom domain.</li><li>The JWKS_URI will be your ‘CORE_URI + /AUTH_GROUP + /jwks’.</li><li>If you’d like to specifically validate a resource audience, add the URL of that resource to the AUD property field. For our example, we’ll leave that blank.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bOSwZfz2w-QQGVkku_tSbw.png" /></figure><p>For more information about the authorizer project and its configuration, checkout the <a href="https://github.com/UnitedEffects/core-eos-oidc-authorizer/blob/main/README.md">README</a>.</p><h4>Step 5</h4><p>Deploy using the following command:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/548/1*CNQRk8coKN7u-hpC9JT9yQ.png" /></figure><p>The instructions assume you have Serverless Framework installed and configured to point to your AWS account; however, you can also build, zip, and manually deploy the service if you with. Keep in mind, the code is written in ES6 and uses babel to build, so lambda should route requests to the handler in ./dist/index.js to work properly.</p><h4>Step 6</h4><p>Choose the API in AWS Gateway that you’d like to secure. In the AWS console, within API Gateway, navigate to “Authorizers” and click “Create New Authorizer”. Fill in the fields as follows and make sure to select the lambda function you deployed in Step 5.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ULPolYXLT3zG5aF4bEFxJQ.png" /></figure><p>You may have to Add Permissions to the Lambda Function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aehHG24-PS7IbqNKAS9Z2g.png" /></figure><h4>Step 7</h4><p>Generate a Client Credential token and test your Authorizer. This is just an http request to Core EOS (CORE_URI + /AUTH_GROUP + /token) where the Client ID and Client Secret from step 1 are used as basic authorization “username” and “password”. In postman, it might look something like this, where Client ID and Client Secret have been base64 encoded to use as basic authorization in the header:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DQKHocLOsms8oTZbPA7DNQ.png" /></figure><p>In Core EOS, the “access” scope returns any user or client permissions associated so we’ve included it here. Notice that no audience resource value was passed, ensuring that the resulting access_token is opaque and not a JWT. That said, this solution would work exactly the same way if it was a JWT. Copy the “access_token”.</p><h4>Step 8</h4><p>Test the access token on your authorizer by clicking test, and pasting the token into the field. The result should look something like the following:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-LVN8EZx-4gbnUDNaFAP9A.png" /></figure><h4>Step 9</h4><p>Wire up the specific endpoint you want to protect. With AWS Console under API Gateway, click into resources and the specific resource/method you wish to protect. In the example image, I am protecting a random “/api” resource which is itself configured as a proxy of all methods to Core EOS (just as an example).</p><p>You’ll notice initially the “Method Request” box shows “NONE” on the “Auth” configuration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*biAGB6ziY6hrUvzywmCHoQ.png" /></figure><p>Click into the configuration and choose your new token authorizer instance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jHr6eAf6zJ94tho4M07z6w.png" /></figure><h4>Step 10</h4><p>Deploy your new configuration of the API Gateway:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/554/1*CKOHrrPh0H4rjlAkvprS_w.png" /></figure><p>You’re all set! Now, if you make http requests to the AWS Gateway endpoint, you will need to provide a header value with Authorization = “Bearer &lt;YOUR TOKEN&gt;”.</p><p>Here you can see the endpoint returning a 401 Unauthorized when I hit it without a token:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N9Cn16H1CZ3Dp313texFvg.png" /></figure><p>And returning the proxied version data from Core EOS when I do provide a token:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Cro7K9_LSJPQLXvDC0QHA.png" /></figure><p>With this approach, its very easy to protect all of your downstream resources behind an AWS Gateway instance. Signup today at <a href="https://unitedeffects.com/">unitedeffects.com</a> to get started, or contact us for a demo at <a href="/service/mailto:solution@unitedeffects.com">solution@unitedeffects.com</a>.</p><p>Follow us on <a href="https://twitter.com/ueffectsLLC">Twitter</a>, <a href="https://www.linkedin.com/company/unitedeffects/">LinkedIn</a> and <a href="https://blog.unitedeffects.com/">Medium</a> and if you need help with anything related to Core EOS, do not hesitate to reach out to <a href="/service/mailto:help@unitedeffects.com">help@unitedeffects.com</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=22f6412f4218" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Core EOS DIY Demo]]></title>
            <link>https://bomotlagh.medium.com/core-eos-diy-demo-6751aa7f0d42?source=rss-c3402d77a1be------2</link>
            <guid isPermaLink="false">https://medium.com/p/6751aa7f0d42</guid>
            <category><![CDATA[coreeos]]></category>
            <category><![CDATA[demo]]></category>
            <category><![CDATA[platform]]></category>
            <category><![CDATA[quickstart]]></category>
            <category><![CDATA[sign-up]]></category>
            <dc:creator><![CDATA[Bo Motlagh]]></dc:creator>
            <pubDate>Mon, 02 May 2022 18:40:49 GMT</pubDate>
            <atom:updated>2022-05-02T18:40:49.434Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/869/1*bfWROn6ydms_t0HL49YTsw.png" /><figcaption>Core EOS by United Effects Logo</figcaption></figure><p>Want to see the power of Core EOS in just a couple minutes? Try the demo outlined below and see it for yourself. Signup today at <a href="https://unitedeffects.com/">unitedeffects.com</a> or contact us at <a href="/service/mailto:solution@unitedeffects.com">solution@unitedeffects.com</a> for more information.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*18yAz4nj2peFgOtA4ss4eQ.png" /><figcaption>DIY Demo Instructions for Core EOS Product Setup</figcaption></figure><p>Follow us on <a href="https://twitter.com/ueffectsLLC">Twitter</a>, <a href="https://www.linkedin.com/company/unitedeffects/">LinkedIn</a> and <a href="https://blog.unitedeffects.com/">Medium</a> and if you need help with anything related to Core EOS, do not hesitate to reach out to <a href="/service/mailto:help@unitedeffects.com">help@unitedeffects.com</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6751aa7f0d42" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Core EOS and AWS AppSync]]></title>
            <link>https://bomotlagh.medium.com/core-eos-and-aws-appsync-ae9bc29a75dd?source=rss-c3402d77a1be------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae9bc29a75dd</guid>
            <category><![CDATA[oidc]]></category>
            <category><![CDATA[coreeos]]></category>
            <category><![CDATA[authorization]]></category>
            <category><![CDATA[platform]]></category>
            <category><![CDATA[aws-appsync]]></category>
            <dc:creator><![CDATA[Bo Motlagh]]></dc:creator>
            <pubDate>Mon, 02 May 2022 16:12:13 GMT</pubDate>
            <atom:updated>2022-05-02T16:12:13.436Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/869/1*B0AKlxLVwfFVQR1HLS-Dcw.png" /></figure><p>Did you know you can use Core EOS with AWS AppSync to authorize your requests? It’s a very easy setup, let’s walk through an example.</p><p>Before we dive in, just a note about the two URLs Core EOS references:</p><ul><li><strong>Core EOS Platform UI: core.unitedeffects.com</strong>, where you interact with the screens and manage your platform and account</li><li><strong>Core EOS OIDC Provider: auth.unitedeffects.com</strong>, the issuer and URL for all OIDC and API requests. <a href="https://auth.unitedeffects.com/api">See documentation here</a></li></ul><h4>Step 1</h4><p>Let’s get started in Core EOS (<a href="https://core.unitedeffects.com/">core.unitedeffects.com</a>). Create a product to represent whatever you are using AppSync for, and then add an API service. Here we are simply adding an API service to our Demo Core product. For this service, we are going to:</p><ul><li>Give it the name “Client Credential Service”</li><li>Add “client_credentials” as the Grant Type</li><li>Scroll down to the bottom and click “Add Service”</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S2tgSdTXemlHz0XTGM7grA.png" /></figure><h4>Step 2</h4><p>Collect your Client ID and Client Secret. You’ll need them for later.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/846/1*ginfwOgQHG6oebTi7wX3Mw.png" /></figure><h4>Step 3</h4><p>Before heading to AWS. Let’s make a copy of our Platform ID. We’ll need it later. Click settings and under Auth Group, you’ll see it. You can copy it using the icon. The image below depicts our Alias as an example, yours will be different.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/1*vZtJbDiAi1o0-wpjxi8QSQ.png" /></figure><h4>Step 4</h4><p>Now let’s setup a demo AppSync project. Just log into your AWS console and navigate to AppSync. From there, click to Create AWS AppSync API. If you already have an API, skip to step 6.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/906/1*IIG_dubK-sEgUhHofWUizQ.png" /></figure><h4>Step 5</h4><p>Go ahead and select a sample project to get an API working asap.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lid_q2EM0BTPiKjdMhh1Tw.png" /></figure><h4>Step 6</h4><p>To configure this API to use Core EOS, you just need to make the following changes. First, choose “OpenID Connect” as your Default Authorization Mode.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*55KnIHQz9qweeoaGSOqdPw.png" /></figure><p>And second, enter your Core EOS issuer URL into the “OpenID Connect provider domain (Issuer URL)” input field. Your issuer URL is the OIDC url + your Platform ID from step 3. If you have a custom domain for the OIDC url, use that instead. Also please note that in most circumstances, your Platform Alias is interchangeable with your Platform ID; however, AWS will require the ID and not the alias for their implementation of OIDC validation.</p><p>auth.unitedeffects.com/YOUR_PLATFORM_ID</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CDx0rCoVegMQQqUp-bIozg.png" /></figure><p>The other fields are optional to provide additional validation; however, there is a known AWS bug with the Client ID field that will cause a validation error (<a href="https://github.com/aws/aws-appsync-community/issues/115">see bug here</a>). It is not required for this implementation to work and we recommend omitting it until AWS resolves the issue.</p><h4>Step 7</h4><p>Now you just need a token! In this example, we are generating a client_credential token; however, other flows such as code_authorization will work just as well. The only requirement is that you end up with a JWT token to provide to AppSync. In Core EOS (and most OIDC implementations), to obtain a JWT as opposed to an Opaque token, you must provide a “resource” parameter that will be used as the “audience” claim of the token. An audience claim tells an underlying system that receives the token whether or not they are the intended audience/recipient. For our example, we will simply use the Core EOS issuer url with the platform alias. Use the curl command below and insert the Client ID and Client Secret from step 2.</p><blockquote><em>curl --user “CLIENT_ID:CLIENT_SECRET” -X POST “</em><a href="https://auth.unitedeffects.com/YOUR-ALIAS/token"><em>https://auth.unitedeffects.com/YOUR-ALIAS/token</em></a><em>&quot; -H “Content-Type: application/x-www-form-urlencoded” -d “grant_type=client_credentials&amp;resource=</em><a href="https://auth.unitedeffects.com/YOUR-ALIAS"><em>https://auth.unitedeffects.com/YOUR-ALIAS</em></a><em>&quot;</em></blockquote><p>This will return your token object which has three properties:</p><ul><li><strong>access_token: </strong>your JWT token</li><li><strong>expires_in: </strong>the seconds until your token expires</li><li><strong>token_type: </strong>in this case “bearer”</li></ul><p>Copy the access_token value.</p><h4>Step 8</h4><p>Navigate to Queries in the AppSync UI and paste the token into the “Authorization Token” field. Click the button to run your request and you’ll see it succeed!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8oKGUNUuIIpxNWwe7Id6PQ.png" /></figure><p>And that’s it! You have now integrated your Core EOS Platform to AppSync and can validate requests. If you haven’t already, sign up today for your free access to Core EOS at:</p><p><a href="https://unitedeffects.com/">United Effects</a></p><p>Follow us on <a href="https://twitter.com/ueffectsLLC">Twitter</a>, <a href="https://www.linkedin.com/company/unitedeffects/">LinkedIn</a> and <a href="https://blog.unitedeffects.com/">Medium</a> and if you need help with anything related to Core EOS, do not hesitate to reach out to <a href="/service/mailto:help@unitedeffects.com">help@unitedeffects.com</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae9bc29a75dd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Core EOS Beta Launch]]></title>
            <link>https://bomotlagh.medium.com/core-eos-beta-launch-a006d5fee2da?source=rss-c3402d77a1be------2</link>
            <guid isPermaLink="false">https://medium.com/p/a006d5fee2da</guid>
            <category><![CDATA[launch]]></category>
            <category><![CDATA[identity-management]]></category>
            <category><![CDATA[platform]]></category>
            <category><![CDATA[access-management]]></category>
            <category><![CDATA[data-fabric]]></category>
            <dc:creator><![CDATA[Bo Motlagh]]></dc:creator>
            <pubDate>Mon, 02 May 2022 14:00:28 GMT</pubDate>
            <atom:updated>2022-05-10T19:02:24.433Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/869/1*bfWROn6ydms_t0HL49YTsw.png" /><figcaption>United Effects Core EOS logo</figcaption></figure><p>We are thrilled to announce that Core EOS Beta is live and ready for production use! In one place, you can manage all of your users, leveraging all the best features, including single sign-on, multi-factor and passwordless authentication, social logins, self-service federated SSO for your customers, and much more. As well as centralize and take control of your user access, roles AND fine-grained permissions for all of your customers, across all of your products. All of this comes as part of an adaptive UI experience that is white-labeled to be YOUR complete platform solution that you can expose to your customers and users. In other words, you don’t need to spend a year building the screens to go along with the solution you just purchased like you do with our competitors.</p><p>And this really is just the beginning. At United Effects, we are committed to commoditizing the idea of the “Platform Play” one feature at a time. Our next innovation will be a complete data fabric we call the Data Stream Storefront, expected before end of year, that will pull all of your data into Core EOS alongside your users, customers, products, and permissions.</p><p>This really is your Platform Play in 2 minutes instead of 2 years.</p><p>Our beta is free to use, and when we are ready to move into paid plans, we will work with you to roll into a reasonable and appropriate pay-as-you-go model. But don’t worry, there will always be a free tier.</p><p>You can sign-up today at <a href="https://unitedeffects.com/">unitedeffects.com</a> or if you’d like a demo, contact us at <a href="/service/mailto:solution@unitedeffects.com">solution@unitedeffects.com</a>. If you have specific features you’d like to see us incorporate, you can join our Design Partners Program, where we will work side-by-side with you to implement a pilot and partner to understand which features would make Core EOS the best possible solution for your business needs so we can prioritize them on our roadmap. You can join the Design Partner Program here: <a href="https://unitedeffects.com/design-partner-program">https://unitedeffects.com/design-partner-program</a></p><p>At United Effects, our mission is to build a platform one last time so you don’t have to. Sign up today and see how Core EOS can save your company time and money best spent on your core business.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FdbYeAfo7gx8%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DdbYeAfo7gx8&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FdbYeAfo7gx8%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/4915a406fd5835c98f04b352fbc9a5c8/href">https://medium.com/media/4915a406fd5835c98f04b352fbc9a5c8/href</a></iframe><p>Follow us on <a href="https://twitter.com/ueffectsLLC">Twitter</a>, <a href="https://www.linkedin.com/company/unitedeffects/">LinkedIn</a> and <a href="https://blog.unitedeffects.com/">Medium</a> and if you need help with anything related to Core EOS, do not hesitate to reach out to <a href="/service/mailto:help@unitedeffects.com">help@unitedeffects.com</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a006d5fee2da" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Configuring MFA with Core EOS and Privakey]]></title>
            <link>https://bomotlagh.medium.com/configuring-mfa-with-core-eos-and-privakey-8b171836c4cf?source=rss-c3402d77a1be------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b171836c4cf</guid>
            <category><![CDATA[mfa]]></category>
            <category><![CDATA[coreeos]]></category>
            <category><![CDATA[help]]></category>
            <category><![CDATA[instruction]]></category>
            <dc:creator><![CDATA[Bo Motlagh]]></dc:creator>
            <pubDate>Thu, 14 Apr 2022 21:51:39 GMT</pubDate>
            <atom:updated>2022-04-14T21:51:39.794Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*Hd1BV6A1-Az0fzgvAeFAdw.png" /></figure><p>When we at United Effects wanted to enable MFA and transaction challenges in our platform, we looked to Privakey for help and they delivered. Their solution was easy to integrate and made it possible to rapidly deliver these features. Our partnership is still evolving, including through the creation of new Privakey APIs that will enable an even more seamless experience than is currently implemented for our customers. For now, the experience has a few extra steps that we wanted to help illustrate for anyone connecting Privakey to their Core EOS Auth Group and enabling MFA.</p><p>Step 1: Download the AuthWallet app from <a href="https://apps.apple.com/tt/app/authwallet/id1552057206?uo=2">iOS</a> or <a href="https://play.google.com/store/apps/details?id=com.privakey.authwallet&amp;hl=en_US&amp;gl=US">Google Play</a></p><p>Step 2: Go to <a href="https://signup.privakey.com/">https://signup.privakey.com/</a> to register with Privakey. Enter your information on the screen which should look like the below.</p><figure><img alt="Screenshot of Privakey Login Screen" src="https://cdn-images-1.medium.com/max/1024/1*bt8u3FoMRbooENOvjZPqIA.png" /></figure><p>Step 3: Registration will result in an email with instructions to set you up with Privakey, which includes adding your admin account to the AuthWallet App using a QR code. Follow those instructions to proceed. As part of this process, you will receive a Company login URL with a GUID, hold on to that. I will look something like:</p><blockquote><a href="https://cloud.privakey.com/portal/login?guid=YOURGUIDHERE">https://cloud.privakey.com/portal/login?guid=YOURGUIDHERE</a></blockquote><p>Step 4: Login to your new Privakey account using your Company URL and GUID. This will result in a challenge on your AuthWallet app. Approve the challenge.</p><p>Step 5: You will be presented with a dashboard upon login. It will look something like the below image except your company name will be listed instead of United Effects. In the example image, we already have an App Space but in yours there will not be anything there. But don’t worry, we are about to add one. Click the “create new app space” link.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i6qFxXkd3tpZappY-oIj6Q.png" /></figure><p>Step 6: An App Space represents a unique pool of users, much like an Auth Group does on Core EOS. In fact, if you have registered more than one Auth Group with Core EOS, you can use this one Privakey account to create multiple App Spaces, one for each Auth Group. On this new screen, enter the name of your Auth Group in the App Space Name text box and make sure that the toggle under “Firebase Configuration” is to the right and the fields just below it are disabled. Lastly, enter in the URI of a logo or image to represent your Auth Group. If you like, you can copy paste the logo url you used for branding your Platform under Settings. When you’re ready to save, it will look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EM6VT3mizW_aQwvnJxMyBQ.png" /></figure><p>Step 7: Once you’ve saved, you’ll end up back at the dashboard and you will see your App Space in the list. On this new screen, scroll to the bottom and click “View / Manage Admins”.</p><p>Step 8: Add yourself as an admin for the App Space. Before you can do anything else, you will need to enter your email address (the same one you used in Step 2) and add yourself as an admin for the App Space. The screen will look like the below image before you save. Once you do save, it will notify you that the screen is about to refresh. After the refresh, you will find yourself back on the Dashboard.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XXNWuYrJocUD7DtqDtQDrQ.png" /></figure><p>Step 9: Click back into the App Space and now click “View / Manage All Request Origins”. On the Request Origin screen, you should see a link that says “Create New Request Origin”. If you do not see this link, it’s possible you have not completed step 8. Click the link.</p><p>Step 10: Give your Request Origin a name, we recommend “Primary Access”, your company name, or even just the name of your Platform/Auth Group again. The most important step here is to make sure you select the Basic radio button under “Credential Type”. It should look like the below before you save.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hm_uub821O1emMdWEjqNYQ.png" /></figure><p>Step 11: Almost there! You should now be looking at the configuration of your new Request Origin. At the top there is an overview and one of the fields is GUID. Save this value to use as your Privakey Client Id later. Under the overview the is a password section with a button that says “Show Password”. Click the button and save the resulting value to use as your Privakey Secret later.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NuQBwOId6MimzfI5U7jtCQ.png" /></figure><p>Step 12: Below the password section, you will see “Configured Callback Urls”. Click “Create New Callback” and in the resulting screen, enter this callback url exactly as typed and shown in the image:</p><blockquote>auth.unitedeffects.com/api/{*}/mfa/callback</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yQLe9vnWJ3krYp8Up4ICmw.png" /></figure><p>Step 13: We have successfully configured Privakey! Now we just need to navigate to Settings in your Platform portal, enable MFA, and paste in the Privakey Client and Privakey Secret values you saved from Step 11.</p><blockquote>https://core.unitedeffects.com/YOURALIAS</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p4dndVFeHonxEk5pgyfVEw.png" /></figure><p>From here, your users can enable their own MFA either by clicking “Enable MFA” in their Account Dashboard (see below) or by clicking “Restore MFA” on any login page. For them the process is very quick. They will be presented with instructions including links to download the Auth Wallet app and a QR code for setup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/894/1*Kuzy9VDTuR3XU0msKOnOiQ.png" /></figure><p>Alternatively, you can simply toggle the “required” switch in your platform settings and all users will be forced through MFA enablement on their first attempt at login.</p><p>We hope this functionality serves you well. Please also know that we are actively working to streamline this process further and reduce the number of steps.</p><p>Visit us at <a href="https://unitedeffects.com/">unitedeffects.com</a> for updates and to contact us. If you need help with this flow, email us at <a href="/service/mailto:help@unitedeffects.com">help@unitedeffects.com</a>.</p><p>Follow us on <a href="https://twitter.com/ueffectsLLC">Twitter</a>, <a href="https://www.linkedin.com/company/unitedeffects/">LinkedIn</a> and <a href="https://blog.unitedeffects.com/">Medium</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b171836c4cf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lessons Learned with Integrations of Teams and Systems When Building Products with Microservices]]></title>
            <link>https://bomotlagh.medium.com/lessons-learned-with-integrations-of-teams-and-systems-when-building-products-with-microservices-97c320d0bbc9?source=rss-c3402d77a1be------2</link>
            <guid isPermaLink="false">https://medium.com/p/97c320d0bbc9</guid>
            <category><![CDATA[agile-process]]></category>
            <category><![CDATA[team-collaboration]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Bo Motlagh]]></dc:creator>
            <pubDate>Wed, 03 Nov 2021 15:29:59 GMT</pubDate>
            <atom:updated>2021-12-09T15:15:18.644Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YAEXqLvUEAifFPxdVzJbzg.jpeg" /></figure><p>A few years ago my team at the time and I needed to help come up with a way to enable multiple distributed teams to build microservices that could be orchestrated to work together to create a seamless experience. The trouble was that our distributed teams were tripping each other up because of dependency management between them.</p><ul><li>Team A was responsible for a microservice on Domain A while…</li><li>Team B was responsible for a microservice for Domain B, but…</li><li>Team C, who was responsible for Domain C, had transactional dependencies for both Domain A and B.</li></ul><p>There were several issues that conspired together to create the delays and difficulties we faced, both process oriented and technological. They included issues with how we mapped domains (too small) and the fact that our UI was a single monolithic UI interfacing with multiple backend components and API definitions. I won’t speak about domain decomposition for domain driven design in this article but we will address it in the future. Regarding the UI, United Effects is implementing an approach to this using micro-frontends which mitigates the issue, but this too is a topic for another time. In this article, I’d like to focus on some of the high-level lessons learned around how development organizations and their teams perceive and address work in a distributed environment, and how those lessons continue to guide my approach today.</p><p>At the time, there were several processes and technologies piloted to address the challenges described. For example, we used SAFe Agile in an attempt to manage dependencies. We also tried out a technical solution to ensure API integrations did not break called <a href="https://pact.io/">PACT.io</a>. Each of these approaches had benefits and costs, but often seemed to slow down progress dramatically. In the end, what I learned was that often we employed these external crutches to account for a simple missing concept: <strong>software development maturity and quality</strong>. We were using these tools and processes to tell us we did something wrong so we could address it after the fact, an approach that inherently slows progress, when instead we should have had conversations up front and designed our code and processes to avoid these situations in the first place. This is the definition of mature quality control, ensuring that your work is free of issues rather than focusing on catching issues after the fact through testing alone.</p><p>With those experiences, here are my lessons learned and my approach to building distributed software and APIs at United Effects.</p><h4>Business vs Technical Concept of a Product</h4><p>I’ve come to realize that there is a perceptual change required when designing and building “products” in a microservice (distributed systems) environment. Typically, we are accustomed to the idea that a product is one concept both from a technology perspective and a business perspective. This 1:1 business to technology perspective is often used as a convenient way to describe all of the resource alignments, costs, and strategies that go into the product. We assume that because it is all in service to this one concept, we can and should finance the effort through a single silo of funding, which in turn, leads to a single team of people who coordinate the stream of work required to take the product from concept to reality, and then continue its support.</p><p>You may have heard of <a href="https://en.wikipedia.org/wiki/Conway%27s_law">Conway’s Law</a>:</p><blockquote>Any organization that designs a system (defined broadly) will produce a design whose structure is a copy of the organization’s communication structure.</blockquote><p>This is an adage I’ve come to realize is almost certainly true; however, as executives and technology leaders attempt to glean insights in organizational design from its implications, I’ve noticed that they often ignore the impact that a siloed funding pattern can have on the resulting organization structure. The result is that our best notions of team allocation, separation of concerns, agile processes, and technology innovations can all be for nothing if ultimately the funding pattern forces us to address our distributed efforts as a single working team, which eventually leads to serialized work streams, which ultimately leads to dependencies, and finally monolithic products.</p><p>The perception of what a “product” is impacts our notion of development processes as well. Developers are often trained to think about Agile implementation as taking a small vertical slice of the product, completing it, and then iterating forward from there. Again this makes sense because in a monolith 1:1 tech-to-business model, a single team (however large) is held responsible for all of the components of the product.</p><p>The problem is that the business definition and technology definition of a product are not 1:1 in a microservice environment. When dealing with decoupled services, each with their own teams and CICD pipelines, you are also dealing with concurrent work streams, all attempting to reach development milestones at the same time. Additionally, the microservices being developed may represent more than one business product. This reality means we must shift our understanding of a product from a technical perspective. The business to technology alignment is now 1:n, where n is the number of concurrently developed backend services required for the business concept being defined.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/903/1*Xd8JP1_qgbhm-OBLl6Xs-w.jpeg" /><figcaption>3 teams take on 5 bodies of work for 3 products where only 3 bodies of work are funded</figcaption></figure><p>In the above picture you can see that while Team A is fine in its funding silo with its monolithic product and technology, Team B and Team C are going to run into trouble. They will trip over each other trying to work out who works on Microservices 2 and 4. They are also taking on additional work that was not funded by their initial value stream.</p><h4>Your Component is a Product</h4><p>If you are a team assigned to building one microservice that will be used in one or more products, you must first trust that your partner teams in charge of those integrations will be responsible for the correct implementation of the interface you provide. Next, you must relieve yourself of the notion that a vertical slice of the product in question requires you to have access to the external integration point.</p><p>Draw a box around your component and think of this as your product. If you must make logical separations of the work, do so within the context of your piece of the puzzle only (i.e. the box). You should also take a moment and try to understand who will actually be the end user of your component. Is it the customer buying the final product? Probably not. Your end user is the team that must integrate with your API. To that end, you should try to productionize your implementation as much as possible so as to ensure end users are successful. All of the rules of product design still hold true… you should work to delight your user, whether they are internal or external.</p><h4>Iteration Is Different with Distributed Systems</h4><p>When dealing with monoliths, there are only so many architectural patterns possible between the UI and database — or rather, you probably have a clear understanding that whichever pattern you choose will continue to be implemented for all functionality. In those situations, it may be ok to work your way across the functional spectrum of the product without fully understanding how the final elements will actually come together. In a distributed system, this can be a dangerous assumption.</p><p>It is true that you may not need to know the low level implementation of every feature of your component, but the potential integrations and interface points are not nearly as concrete and well established as they are in a monolith. You have no idea how an integrating team will break your interface (and someone will break it).</p><p>It is my experience that to promote the best possible chance of success, you should actually create a wide but shallow horizontally complete implementation of your interface immediately. Define the API, define temporary controllers, define the database schemas and wire this all together into a skeleton of the overall component. From there you can back up and iterate one controller or class at a time to complete the functional implementation.</p><h4>Define and Version your API Manually</h4><p>I suspect this will be a more controversial point. I am of the opinion that an API should be defined and maintained manually, especially when that API is REST and communicated through JSON Schema via OpenAPI. Allowing auto generation of the API definition is problematic for a few reasons but 3 of my standouts are:</p><ol><li>We immediately break the previously stated lesson learned of creating an initial shallow but wide implementation of the interface.</li><li>We are at the mercy of the library generating the API definition and it’s supported versions of the API specification language.</li><li>Independently versioning an automated specification can be tricky.</li></ol><p>Manually managing your API specification has many advantages:</p><ul><li>Immediately defining the API before coding allows partner teams to get a sense of what they will need to build for client integrations.</li><li>API specifications such as OpenAPI can also be used to generate code for client integrations, test services and more, long before full functionality is completed.</li><li>API specifications can act as requirements for the code implementation, ensuring that teams discuss the intended result and do not accidentally coding something unintentional that would be a breaking change.</li><li>A single versioned API specifications can be the source of truth for your component’s interface. Multiple concurrently operating teams, along with the implementing team, can all rely on this source of truth to build matching validation tests independently without the need for excess coordination.</li><li>Many API definition specifications like OpenAPI also allow you to include detailed descriptions, instructions and other metadata which can then be used to generate easy to navigate documentation, further productionizing your component for your end users.</li></ul><p>With all of this said, perhaps the best reason to do this is simply to force every member of the team to understand what the API does or does not do so that they can better support the component.</p><h4>Version the API and Code Together</h4><p>The simple truth of managing distributed systems is that you have to be able to tell two running instances of the same service apart in a predictable way. The simplest way to do this is through versioning every component and every API.</p><p>I advocate versioning the API of a service along with the code as a single unit within a source control repository like GitHub. My preference is a semantic version syntax of “major.minor.patch” (e.g. 1.2.3). I think it is important to get into the habit of incrementing the version even when the change is very minor or a simple patch. This helps ensure a level of maturity and specificity regarding exactly what is being deployed at any moment, which will come in handy if and when your organization pursues any sort of SOC certifications in the future. Every commit to the main branch of your code should result in a version change that is documented, even if it is never deployed. Transparency is the name of the game.</p><h4>If You Have to Integrate, Pick Stable Versions</h4><p>I have seen teams attempt to work together by creating live dependencies on each other’s development branches in GitHub. The approach assumes neither team will ever have bugs or issues, so the fastest possible implementation is one that utilizes the newest possible code. This is a flawed idea. There will be bugs and the only thing this approach will accomplish is that the teams will simply take turns delaying each other through unexpected integration issues.</p><p>Remember that each component should be considered a product unto itself. You would (hopefully) never intentionally release untested and potentially buggy code to a customer, and so you should not do so to your potential end users (other teams) here.</p><p>If you must have integration points, designate a stable branch with a known version and release it for consumption as you would any other product. Alternatively, if you are using containers, define a stable version tag to indicate latest safe images to pull (you should always have images tagged with your versions anyway, latest or otherwise). If you are integrating with another team, ask for this branch or image and only integrate with the version of the code and API represented there. If you need new functionality, ask for the changes as you would any service provider and wait until it is released.</p><h4>Have a Process to Deprecate APIs or Functionality</h4><p>Define and communicate how deprecated interfaces or functions will be handled. Define a window of time where you communicate the change and then follow through with the change. The first few times, you may break someone who deprioritized handling the deprecation warning; however, this kind of hiccup is good for the larger organization as it promotes positive growth and maturity. If you don’t follow through, you will create an expectation that nothing will get deprecated, and over time this can become a headache. Moreover, if eventually you do pull the trigger, the resulting changes could create more risk than anticipated because of the technology debt having piled up.</p><h4>Design Your Code for Quality Validation and Testing</h4><p>A team should be writing unit tests, mocked integration tests, and some post-deployment smoke tests. These tests should all be part of the component CICD process. I am of the opinion that nothing about these tasks requires (though certainly does not preclude) a dedicated tester or automation engineer. I am also of the opinion that 100% coverage, while nice, is not a necessity.</p><p>Tests are not an artifact of business value in and of themselves. You don’t sell the tests. Tests are insurance… a price you pay in the hopes of averting an even bigger cost later. Nevertheless, we should evaluate the prioritization and cost of tests just as we would any feature of the system. My general approach is to create a decomposition of the component I am designing or implementing and identify high value or high risk functional areas that require coverage. High value functional areas are parts of the system that directly drive business opportunity. High risk functional areas are those that have the potential to drive business to a halt.</p><p>With that said, before tests can be written, the code must be designed for ease of testing. In my experience, this is a non-obvious skill set for a lot of developers to learn. A few observations:</p><ol><li>Unit tests require discernable units of functionality. If you can’t delineate those units just by looking at your code, you are probably going to have some trouble figuring out how to write a test.</li><li>Whether you are using Object Oriented, Functional, or some other or hybrid coding approach, the key to testability is modularity and low complexity of design. If you create a highly performant algorithm that recursively iterates across 20x different looping functions, you’ve created complexity. Maybe that’s a necessity for your implementation, but more often than not there is a less complex way to define the same algorithm which may trade negligible performance increases for readability and easier testing of the individual methods being called.</li><li>Pay attention when mocking dependencies. Sometimes the need for a test seems obvious despite a large number of dependent components being required. I’ve had the experience of beginning the process of mocking those components one by one until I finally realize that my method is not actually doing all that much on its own, but rather coordinating a bunch of integrated classes and libraries. At that point, you have to ask, what are you really testing? Remember that unit coverage isn’t a good excuse for a test. If it were, you could just write an “assert(true)” test for everything and be done.</li><li>If you can design an element of your functioning live code to self-validate in real-time or build-time, you eliminate the need for a test.</li></ol><p>There are a few examples of this last point in action out there. Anyone who has ever coded in an interpreted language vs a compiled one knows that an interpreted language often requires additional testing to catch bugs that might otherwise be caught by a compiler. This is one of the clear advantages of TypeScript over straight Node JavaScript (though I admit I have not fully transitioned yet).</p><h4>My Approach to REST APIs</h4><p>One of my favorite ways to utilize the design concept of self-validation in code is in the REST API itself by validate all incoming requests against an OpenAPI specification. This implementation provides several benefits:</p><ul><li>Confidence that requests coming into a service do not have unexpected properties or instructions that the implementation may have neglected to ensure the controller or business layers ignore, removing the need for a lot of negative tests.</li><li>Request bodies are trusted and mapped to data layer models without a lot of modification.</li><li>An integrating consumer will know immediately if an expectation about the API is wrong as they will get a 400 error upon the first request.</li><li>Service tests and code can use the OpenAPI specification directly to catch breaking or unexpected changes before deployment.</li><li>Updates to the specification will immediately create an inconsistency between the code and API which can serve as a TDD style requirement for development and stop deployments in the CI pipeline until resolved.</li></ul><p>You can find my approach to this concept in my boilerplate template here:<br><a href="https://github.com/theBoEffect/boilerplate">https://github.com/theBoEffect/boilerplate</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*018xEq80QVJwGY4PV2YikQ.jpeg" /><figcaption>diagram of implementation with code snippets</figcaption></figure><p>I hope you’ve enjoyed this perspective and overview about how United Effects approaches these common questions regarding development processes to bring our product Core EOS to market. If you’d like hear more about this topic or Core EOS, visit <a href="https://unitedeffects.com/">unitedeffects.com</a> and contact us!</p><p>Follow us on <a href="https://twitter.com/ueffectsLLC">Twitter</a>, <a href="https://www.linkedin.com/company/unitedeffects/">LinkedIn</a> and <a href="https://blog.unitedeffects.com/">Medium</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=97c320d0bbc9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Organization Roles and Departments]]></title>
            <link>https://bomotlagh.medium.com/software-organization-roles-and-departments-585d3f626f2e?source=rss-c3402d77a1be------2</link>
            <guid isPermaLink="false">https://medium.com/p/585d3f626f2e</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[unpopular-opinion]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[organizational-design]]></category>
            <category><![CDATA[organizational-structures]]></category>
            <dc:creator><![CDATA[Bo Motlagh]]></dc:creator>
            <pubDate>Mon, 13 Sep 2021 21:42:17 GMT</pubDate>
            <atom:updated>2021-09-16T19:11:57.855Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CS_apV3RNZJVkyVtDpeBtQ.jpeg" /><figcaption>Image provided by: <a href="https://pixabay.com/photos/computer-cyber-investigation-3028682/">https://pixabay.com/photos/computer-cyber-investigation-3028682/</a></figcaption></figure><p><strong>Opinion: </strong>I think there is something myopic about many (not all) software companies and how they tend to organize themselves in the name of “scale”.</p><p>I have worked at a lot of software companies. Before my shift to Platform technologies and architecture, I was a consultant, traveling all across North America. I think I ended up working at roughly 80 or so companies in one respect or another during that 10 year period. This is all to say, I’ve seen a lot of organizations and how they are structured. I have seen these companies through the lens of a contractor, consultant, full time developer, enterprise architect, product manager, development manager, and executive. It seems important to state that my opinions and analysis is based solely on that experience and that I am not a professional organization development researcher. I say that because experts are important, and if you’re reading this and you are one, I’d love to hear from you.</p><h4>First, Some Observations</h4><p>There is an agreed upon truth that all technology leaders seem to know, rarely verbalize, but still hold on to as an “ace up their sleeves”.</p><blockquote>A development/product team of 2–4 people without direct supervision will always run circles around a traditional engineering team or even the department.</blockquote><p>This statement does not mean 2–4 people are enough to build any product. Just that 2–4 people move very fast. I know this from personal experience on multiple levels.</p><ul><li>First, I have my own 4 person team with United Effects and we are making fast gains. Before that, I have created entire software solutions from concept, to mocks, to monetized product launch in 3 months or less and I did it with just 3 people (counting me).</li><li>Second, I have done what most enterprise leaders do in large companies and had my short list of people “who can get it done”. This is the “ace up your sleeve” maneuver. You have your swat team, who are usually a subset of a larger group, and you know that if your back is against a wall, you can put these people in a room, close the door, and when they come out again it will be done.</li><li>I have been the “ace up the sleeve”. In times of unforeseen struggle, delays, and other factors that seemed to slow delivery beyond reason, I have been asked to simply do the work by myself. I’ve had this happen to me as an engineer, as an architect, and yes even as a director. And I delivered.</li></ul><p>Knowing this fact, that small teams of capable people tend to deliver quickly when you stay out of their way and don’t bog them down with process, why do most organizations create complex delivery processes, bureaucracy and large teams? If you ask them, it’s because of scaling product delivery. I know this because for a long time I said this too despite my nagging thought that something was off.</p><p>I think intuitively I’ve always found this logical dissidence problematic. The notion is that you cannot scale small teams who work quickly and efficiently on their own, and so you need big teams. I learned big corporate scaling practices based on notions (notions being an important qualifier here) of Agile. I’m not going to get into all of them but I will call out the one you have all probably worked with by now, <a href="https://scaledagile.com/what-is-safe">SAFe</a>.</p><p>To be fair to SAFe, there are a lot of interesting templates, processes, and concepts to draw inspiration from within this delivery structure (I’m a huge fan of WSJF). SAFe purposely calls them competencies because these are concepts that when learned can help you. They are not a blind checklist for “how to delivery your late project faster”. The problem is that this is not how SAFe is usually implemented. Every time I hear someone tell me, “SAFE says we do this…” I know that they’ve missed the point, or worse, decided to use SAFe as a shield to push their own agenda. Still, this is understandable because in my opinion the problem is deeper than just processes or Agile or SAFe.</p><p>When we think about enterprise software delivery, we are forced to discuss the myriad of roles associated: Development Manager, Product Manager, Program Manager, Software Architect, Enterprise Architect, Product Owner, UX Designer, Backend Software Engineer, UI Software Engineer, Full Stack Software Engineer, QA Tester, QA Analyst, QA Automation Engineer, Release Engineer, Systems Engineer, Infrastructure and Operations Engineers, And, yes… even more.</p><p>Large enterprises have all of these roles and titles. I’ve held many of them over the years. If you’re looking for complexity, let’s go back to SAFe and look at their admirable job at attempting to bring all of these roles together into a diagram that explains what they do:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A-FaJphhjd0WBlMjnYg9bw.png" /><figcaption>Diagram from <a href="https://www.scaledagileframework.com/#">https://www.scaledagileframework.com/#</a></figcaption></figure><p>You know what I see? I see a conveyor belt in a factory.</p><p>In no way am I saying the skills associated to these roles are invalid or not needed. Nor am I saying that any one person could do all of these things. What I am saying, is that there is a logical disconnect between the reality of what we know delivers quickly (small team empowered without much management) and a structure that defines over a dozen roles to do the same thing at scale but much slower. And this brings me to my next observation:</p><blockquote>We often create role distinctions to serve the process rather than the product.</blockquote><p>I remember when I first gained the title “Enterprise Architect”. At the time, my title was Principal Engineer, which I took to mean “person who has some ideas people should consider” more than anything else. I was happy with that title, but the company I was in was restructuring and there was a notion that I should report to the CTO and help him implement a technology strategy. When discussing with him, he said, “I think you should be my Enterprise Architect.” I remember not really knowing what that means. I asked what my responsibilities would be and he described what to me seemed like my current role. I googled “Enterprise Architecture” and all I found was a tool to model enterprise architecture… which I realized I had been doing anyway. Still, it was a raise, a promotion to report to the CTO of a large company, and clout from being one spot away from the C-suite. Then I realized that this wasn’t about anything other than politics. They needed me to keep doing the same thing I was doing. They just wanted to position me better within a newly constructed hierarchy of authority.</p><p><em>I should pause here and say, this was a key turning point in my career and an amazing opportunity. I have nothing but respect and gratitude for that CTO and the opportunity he gave me.</em></p><p>Coming back to the point, I was fully capable of being an Enterprise Architect or a Developer or a Software Architect… but those titles were not the point. The job was the same. On the surface this may not seem like a big deal and we could simply chalk it up to the price of corporate growth, but I’d like to suggest that this is problematic because ultimately this kind of thinking represents an inefficiency which slows productivity and artificially creates new human resource costs that may not need to be there.</p><p>As an example, I once had a real conversation with a technology leader as an Enterprise Architect regarding a product I was designing. I was explaining the requirements and he stopped me and said, “You shouldn’t tell me requirements. You’re the architect. Find a product manager and have them tell me.” I responded that all that would mean is that I’d have to prepare a presentation for the Product Manager so he could then present my ideas under a new title. The leader was quietly thoughtful for a moment but ultimately did not relent. It was not my job, was his conclusion, and I should not be trusted with that accountability, specifically the trajectory of a product and user experience.</p><p>I don’t blame this leader. We (technologists) are indoctrinated into the idea that there is something special about these titles. That when you shift your career toward one, you somehow lose all professional capability in the other. We measure the success of others through the trials and success of ourselves and as a veteran of an industry that forced him to choose a pigeon holed path, it is not surprising that his thinking would be molded in the same direction when dealing with others. We tend to forget that we made all these processes and titles up ourselves.</p><p>The problem here is that these titles and these roles exist to quantify a process, not to build a product.</p><p>We see the same pattern emerge in other areas. Quality Assurance for example, is a discipline in which I spent years consulting. One of the biggest anti-patterns I often had to help unwind was the notion of a QA organization that measured success by number of tests and defects. In an industry where money is made by avoiding defects, and sales are based on the production code, not the number of tests, somehow these enterprises had evolved to incentivize increased time to market through unnecessary testing and the rewarding of defects found instead of the absence of defects in production. I suppose it’s understandable. It is easier to reward a positive (in this case tests and defects) than a negative (the absence of issues) because it is easier to quantify the former and define a dollar value. But it hurts the business, as any investment in the opposite of fast and bug free delivery would. Here we see not just role distinctions being created to serve a process, but work being created to serve the process. Work that bleeds investment from the product.</p><p>I’m on a bit of a roll so I should pause and say that I am not saying that there should not be QA Engineers or Architects. Those are skill-sets and they are vital. But roles (jobs) and skills (things we know how to do) are different. What I’m saying is that we seem to love defining roles even when what we really need is an investment in more skills.</p><p>Earlier I said that SAFe diagram reminded me of a conveyor belt. That shouldn’t be a surprise. <a href="https://en.wikipedia.org/wiki/Waterfall_model">The first software SDLC was Waterfall by Winston W. Royce and it was heavily influenced by manufacturing and construction industries.</a> Every model we have evolved from this beginning is an attempt to capitalize on the rapid modernization of product development tooling. The disconnect between this legacy and the current reality is in the nature of the word “engineering”.</p><p>Traditional engineering fields such as civil, mechanical, or electrical require regimented, methodical, carefully planned blueprints, and often legally recognized professional qualifications beyond a graduate degree (PE). In these fields, the act of designing is painstaking and detailed because the act of implementation is expensive. If you slap together a blueprint for a bridge or a new microprocessor and teams of people or factories are requisitioned to implement your design, you can’t simply stop in the middle and say, “…hey I forgot something, let’s go back.”</p><p>These skills require a regimented and rigid waterfall like structure to ensure success and even safety. Conversely, Software Engineering is extremely forgiving to scope change (…not an invitation to or endorsement of scope creep). In the 1970’s, when waterfall was introduced, this was not the case. Software engineering projects were as difficult to rollback and alter as any other engineering project. Today, this is simply not the case. The myriad of tools now available to software developers allow them to prototype, develop and refactor functionality in hours. No other “engineering” discipline can make this claim.</p><p><strong><em>Note: </em></strong><em>We are speaking about new development not legacy systems or tech-debt.</em></p><p>This reality has changed the way people practice software engineering. Developers today take a more relaxed approach to the creation processes, accepting the risk of mistakes in favor of rapid development and even accidental innovation because most mistakes can quickly be addressed. While software engineering still requires a clear understanding of systems architecture, data modeling, computer architecture, and mathematics, in my opinion, the act of writing code has become almost a creative activity as opposed to a factory oriented step by step process.</p><p>This brings us to the final observation:</p><blockquote>Modern technology organization structures seem designed to cater to these roles rather than the products.</blockquote><p>Having all of the roles we’ve discussed present in an organization forces us to consider ways to help those roles work together and keep them productive. That conversation I had with the technology leader about what it means to be an Architect vs. a Product Manager was in part fueled by a need to ensure there continues to be Product Managers (the role) and that my actions would not undermine that corporate construct.</p><p>We create logical groupings of people: Product, Engineering, PMO, Architecture, IT, etc. We silo them, give them independent career growth trajectories, and we protect their spheres of influence from excess overlap. In other words, we incentivize a conveyor belt mentality of people management, we ask them to focus on their section of the process only, and we ask that they not deviate into each other’s lanes too much. Once these physical structures are in place, we follow it up with a request that they then find ways to work with each other anyway… we call it a <a href="https://www.mckinsey.com/business-functions/organization/our-insights/the-helix-organization">helix model</a>. This incongruity of form and function is complicated and honestly I’ve never seen it be 100% effective.</p><p>Ok… this is getting long and I’ve dug a 2200 word hole.</p><h4>Now What?</h4><p>First a concession: I actually agree that the argument that 2–4 people move faster than an enterprise in and of itself does not provide a scalable solution to the problems I’ve described above. My purpose was to point this out simply as a beginning for a train of thought that could show the logical inconsistencies our normal processes tend to ignore.</p><p>Next, I’ll say that I do not have a single vetted solution. What I do have is a theory that I plan to flush out and implement at United Effects. Given the length of this article so far, I won’t be able to dig deep into that theory here. For now I’ll try to convey the basic idea and follow up with more detailed blog posts later.</p><p>I should also mention that concepts I want to try are not my inventions. They come from a mix discussions with peers, <a href="https://unitedeffects.com/#team">my own team</a>, and readings on how some companies have experimented with non-traditional org structures. In fact, I’d like to make a shout out to my friends <a href="https://www.linkedin.com/in/christopherzangrilli/">Chris Zangrilli</a> and <a href="https://www.linkedin.com/in/alansoucier/">Alan Soucier</a>. Independant conversations with them over the last year have allowed me to better verbalize these thoughts and ideas.</p><p>My general idea exists in three parts (for now):</p><ol><li>Early on with United Effects, instead of separating the organization into siloed organizations dedicated to the potential roles associated to software delivery, I will be creating organizational groups explicitly dedicated to the objectives of the business both in form and function. That is to say, instead of separate Architecture, Engineering, and Product and Sales organizations, I will create a <strong>Customer Enablement Organization</strong>, dedicated to the notion that everything they do is in service to the customer and product and designed to support revenue. I will extend this concept to other aspects of the business as well. Instead of separate sales and strategy groups, I will create a <strong>Revenue Enablement Organization</strong>. Instead of separate marketing, public relations, and brand we will have a <strong>Market Enablement Organization</strong>. The purpose of these names and these groups is to allow each to bring in whatever talent is necessary to meet the objective and mandate of the group in the fastest most obvious way possible without the politics of role divisions. This does not mean there will not be individual roles, but it does mean that the objectives and incentivization of each group will be clear at all times. It means unification.</li><li>As we grow, we will work to create scalability by empowering groups to deliver fully realized solutions and revenue through single streams of accountability. Within Customer Enablement, Product lines will be individually accountable to provide Research, Design, Implementation, Marketing and initial Sales. We will want to replicate the success of small organizations by providing a mechanism to spawn and control them at scale. Like a business oriented fractal pattern.</li><li>Growth tends to push people and organization toward specialization. This is normal and we will not fight the tendency; however, we will also endeavor to avoid distinctions in roles and responsibilities when there is no logical reason beyond “traditional thinking”. Being one team means giving everyone the opportunity to contribute across various skill-sets, being honest when training is required, and allowing your people to bring their full selves to the table without constraints. We need to stay as far away from hand-off culture as possible.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/711/1*vUgs92B4Lq7JbwhrSkO9-g.jpeg" /></figure><p>As I said, I will spend some time digging deeper into these thoughts in future articles. Does this spark any ideas for you? If so please comment or reach out as I’d love to hear from you. Either way, this is just a beginning and I will write about our successes and failures as we flush out and test these ideas.</p><p>I should also mention that a business/organizational approach to product development that focuses on value streams does not necessarily translate to a technology strategy that silos components by value stream. The technology strategy is separate and our CTO <a href="https://chrisbetz.unitedeffects.com/">Chris Betz</a> and I will discuss this in future writings.</p><p>If you are interested in how these ideas will come together toward a product, please go to <a href="http://unitedeffects.com/">unitedeffects.com</a> and click ‘Join the Core’ and we will make sure you stay in the loop on all of our progress.</p><p>Follow us on <a href="https://twitter.com/ueffectsLLC">Twitter</a>, <a href="https://www.linkedin.com/company/unitedeffects/">LinkedIn</a> and <a href="https://blog.unitedeffects.com/">Medium</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=585d3f626f2e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>