<?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 Rohit Ravikoti on Medium]]></title>
        <description><![CDATA[Stories by Rohit Ravikoti on Medium]]></description>
        <link>https://medium.com/@rovvum?source=rss-f6438fcb514a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*GhAwSHN43nefc_vKW0rxRg.png</url>
            <title>Stories by Rohit Ravikoti on Medium</title>
            <link>https://medium.com/@rovvum?source=rss-f6438fcb514a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:35:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rovvum/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[GraphQL Code-First and SDL-First, the Current Landscape in Mid-2019]]></title>
            <link>https://medium.com/novvum/graphql-code-first-and-sdl-first-the-current-landscape-in-mid-2019-699f68b31a65?source=rss-f6438fcb514a------2</link>
            <guid isPermaLink="false">https://medium.com/p/699f68b31a65</guid>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[graphql-nexus]]></category>
            <category><![CDATA[typegraphql]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[apollo-graphql]]></category>
            <dc:creator><![CDATA[Rohit Ravikoti]]></dc:creator>
            <pubDate>Fri, 12 Jul 2019 15:06:48 GMT</pubDate>
            <atom:updated>2019-07-12T15:43:55.676Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fPp6NzWsoZRMp5vhY6KD3g.png" /></figure><p>There has been a lot of buzz in the GraphQL community around code-first or SDL-first schema development as of late. The purpose of this blog is to shed some light on the current state of the ecosystem and help teams make a decision on which approach would be best for them.</p><p>To understand where we are today, it helps to take a look at how we got here.</p><h3>Code-first: the original way to build a graphql schema</h3><p>Facebook originally released <a href="https://github.com/graphql/graphql-js">graphql-js</a> as a reference implementation for the GraphQL specification. The schema is defined as a plain javascript object:</p><pre>const { GraphQLSchema, GraphQLObjectType, GraphQLString } = require(&#39;graphql&#39;)</pre><pre>const schema = new GraphQLSchema({<br>  query: new GraphQLObjectType({<br>    name: &#39;Query&#39;,<br>    fields: {<br>      hello: {<br>        type: GraphQLString,<br>        args: {<br>          name: { type: GraphQLString },<br>        },<br>        resolve: (_, args) =&gt; `Hello ${args.name || &#39;World!&#39;}`,<br>      },<br>    },<br>  }),<br>})</pre><p>Many people in the community felt that writing a schema in this way was very verbose, and it was challenging to have a mental model of the schema while implementing it.</p><h3>Enter SDL</h3><p>The Apollo team released graphql-tools, which popularized the Schema Definition Language (SDL). Here is what the same schema from above looks like defined in SDL:</p><pre>type Query {<br>  hello(name: String): String<br>}</pre><p>It was much easier to understand the structure of the schema with SDL and, ultimately made the schema design process much more intuitive. The Apollo team also came up with <a href="https://www.apollographql.com/docs/graphql-tools/schema-directives/">schema directives</a> to accompany the SDL.</p><p>One significant tradeoff for the SDL-first approach is that resolvers need to be implemented separately from the schema definition. Consequently, <a href="https://www.prisma.io/blog/the-problems-of-schema-first-graphql-development-x1mn4cb0tyl3#analyzing-the-problems-of-sdl-first-development">various new challenges</a> came about. Directives are also <a href="https://github.com/graphql/graphql-js/issues/1343">not</a> a part of the core GraphQL specification.</p><h3>The pendulum swings back to code-first</h3><p>Tools like <a href="http://typegraphql.ml/">TypeGraphQL</a> and <a href="https://nexus.js.org/">GraphQL Nexus</a> were released to reduce the verbosity of graphql-js and provide a much simpler way to develop schemas than the SDL approach. These tools are built with graphql-js at their core, so they do not have support for schema directives — here are issues requesting support for them in <a href="https://github.com/19majkel94/type-graphql/issues/77">TypeGraphQL</a> and <a href="https://github.com/prisma/nexus/issues/53">GraphQL Nexus</a>.</p><h3>Federated schemas…</h3><p>The Apollo team recently introduced the <a href="https://blog.apollographql.com/apollo-federation-f260cf525d21">Schema Federation</a> specification for building distributed graphs. It significantly improved on a lot of the pitfalls of schema stitching and enabled a truly distributed architecture. The specification utilizes schema directives, so individual schemas can provide hints to the gateway server on how they are related to one another.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tKMI6wsfV4IGdBudipOK7g.png" /></figure><p>The major problem here is that the code-first libraries are unable to support schema federation because they do not support directives. There have been issues submitted for <a href="https://github.com/19majkel94/type-graphql/issues/351">TypeGraphQL</a> and <a href="https://github.com/prisma/nexus/issues/148">GraphQL Nexus</a> requesting support, but there hasn’t been much progress as of yet.</p><h3>So, code-first or SDL-first?</h3><p>Innovation will come with its fair share of disruption, and the GraphQL ecosystem is no exception. There are risks and tradeoffs when selecting any toolset, and teams must carefully look at their circumstances to understand which approach suits their needs.</p><h4>Here are a couple of suggestions:</h4><ul><li>If your team needs schema federation or directives, then it is best to go with the SDL-first approach until the ecosystem catches up.</li><li>If your team doesn’t need schema federation or directives, then it is best to go with code-first — especially if you have a large schema. It will help your team keep your codebases organized and moving quickly.</li></ul><h4>What if you made the wrong choice?</h4><p>The silver lining here is that you are not necessarily stuck with the decision your team makes now. Because both approaches are fundamentally the same (you define a schema and resolvers), it is not difficult to reuse most if not all of the business logic when switching from one approach to the other. One thing to note is that it is currently much easier to start with code-first and then switch to SDL-first because of the lack of schema directive support in code-first.</p><p>I hope this proved helpful for teams struggling to stay on top of everything that is happening in the GraphQL ecosystem. You can always reach out to us at <a href="https://www.novvum.io/contact-us">Novvum</a> for help!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=699f68b31a65" width="1" height="1" alt=""><hr><p><a href="https://medium.com/novvum/graphql-code-first-and-sdl-first-the-current-landscape-in-mid-2019-699f68b31a65">GraphQL Code-First and SDL-First, the Current Landscape in Mid-2019</a> was originally published in <a href="https://medium.com/novvum">Novvum</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducing GraphQL Birdseye ]]></title>
            <link>https://medium.com/novvum/introducing-graphql-birdseye-1d6b76e801c3?source=rss-f6438fcb514a------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d6b76e801c3</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[visualization]]></category>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Rohit Ravikoti]]></dc:creator>
            <pubDate>Tue, 23 Apr 2019 19:55:07 GMT</pubDate>
            <atom:updated>2019-04-24T22:33:03.918Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qg2uZJc1ZvVZM4WNLxsoog.png" /></figure><p>We are proud to officially release <a href="https://github.com/Novvum/graphql-birdseye">graphql-birdseye</a>! Birdseye allows you to view any GraphQL schema as a dynamic and interactive graph. Try it out on our <a href="https://birdseye.novvum.io/">demo site</a>!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QcqM1X6b4wlo2AUWHn_5zQ.gif" /><figcaption>“fog of war” interaction</figcaption></figure><p>Birdseye uses a “fog of war” 🌁 navigation style which dynamically zooms to show a portion of the schema at a time. This significantly simplifies the process of finding related types when compared to displaying the entire schema at once.</p><h3>Getting started</h3><p>You can get started with birdseye by reading the instructions <a href="https://github.com/Novvum/graphql-birdseye#installation">here</a>. The library is currently available as a React component, but if we get requests for other frameworks like Angular or Vue, we would be happy to work on those as well 🙂.</p><h3>Why we built it</h3><p>We were inspired to make a GraphQL schema visualization tool that can you can add to other sites and packages. We have seen a couple of other excellent tools like <a href="https://brbb.github.io/graphql-rover/">graphql-rover</a>, <a href="https://www.npmjs.com/package/graphql-voyager">graphql-voyager</a> and <a href="https://graphqleditor.com/">graphql editor</a>. We originally planned to integrate voyager with <a href="https://github.com/prisma/graphql-playground">graphql-playground</a>, but it would have added 1.2 MB to the package. This bundle size made the library very difficult to integrate with any other tools.</p><p>To solve this problem we created Birdseye which is <strong><em>lightweight</em></strong> and works well with other tools. In this process, we also made some helpful changes to the user experience (📣 to <a href="https://www.prisma.io/">Prisma</a> for helping brainstorm the “fog of war” navigation).</p><h3>How we built it</h3><p>When we first started, we spent the first month trying out various diagramming libraries like <a href="https://github.com/tgdwyer/WebCola">WebCola</a>, <a href="http://js.cytoscape.org/">Cytoscape.js</a>, <a href="https://github.com/dagrejs/dagre">dagre</a> and many more. Some libraries supported a portion of the features while others supported a different subset. At this point, we considered building our own visualization library, and we quickly realized how crazy that would be 😅.</p><p>We decided to keep looking and finally came across <a href="https://resources.jointjs.com/docs/jointjs/v2.2/joint.html">JointJS</a> 🎊. It gave us a nice API to be able to define custom shapes and provided excellent layout and link routing algorithms. It also gave us the ability to modify these algorithms according to our needs. Best of all, it added very little to the bundle size (~70kb).</p><p>Having settled on JointJS, the rest of the project focused on understanding the API in more detail and using it to build out the library. Some of the other tools we used to make this happen were:</p><ul><li><a href="https://www.typescriptlang.org/"><strong>TypeScript</strong></a><strong>:</strong> our go-to language whenever we can use it. The type-safety saves us from a lot of trouble by catching simple issues early on.</li><li><a href="https://rollupjs.org/guide/en"><strong>Rollup</strong></a><strong>:</strong> A bundler that specializes in packaging libraries.</li><li><a href="https://github.com/ariutta/svg-pan-zoom"><strong>svg-pan-zoom</strong></a><strong>:</strong> Simple pan/zoom solution for SVGs in HTML. It adds events listeners for mouse scroll, double-click, and pan.</li></ul><h3>Where we go from here</h3><p>We are committed to improving this library and make it the go-to for visualizing your schema. We would love to hear your feedback so we can make it even better and we always welcome contributions. Some things we are planning to work on are:</p><ol><li>Improve performance for larger schemas</li><li>Option to toggle zoom navigation style</li><li>Smoother UI transitions and interactions</li></ol><h3>Tell us what you think 🤔</h3><p>If you like Birdseye, please follow us on twitter (<a href="https://twitter.com/novvumio">@novvumio</a>) and give us a star 🌟 on <a href="https://github.com/Novvum/graphql-birdseye">GitHub</a>! If you find any issues, we’d love to fix them! You can submit them <a href="https://github.com/Novvum/graphql-birdseye/issues">here</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d6b76e801c3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/novvum/introducing-graphql-birdseye-1d6b76e801c3">Introducing GraphQL Birdseye 🦅</a> was originally published in <a href="https://medium.com/novvum">Novvum</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TypeGraphQL and GraphQL Nexus — A Look at Code-First APIs]]></title>
            <link>https://medium.com/novvum/typegraphql-and-graphql-nexus-a-look-at-code-first-apis-7728f26d7e0d?source=rss-f6438fcb514a------2</link>
            <guid isPermaLink="false">https://medium.com/p/7728f26d7e0d</guid>
            <category><![CDATA[prisma]]></category>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[typegraphql]]></category>
            <category><![CDATA[graphql-nexus]]></category>
            <category><![CDATA[code-first]]></category>
            <dc:creator><![CDATA[Rohit Ravikoti]]></dc:creator>
            <pubDate>Tue, 16 Apr 2019 18:10:03 GMT</pubDate>
            <atom:updated>2019-04-19T19:54:51.022Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6xgfhg4D74iVEJViUgRFyw.png" /></figure><h3>TypeGraphQL and GraphQL Nexus — A Look at Code-First APIs 👀</h3><p>Ever since the Prisma team <a href="https://www.prisma.io/blog/introducing-graphql-nexus-code-first-graphql-server-development-ll6s1yy5cxl5/">announced GraphQL Nexus</a>, there has been much interest in code-first schema development. Here at <a href="https://www.novvum.io/">Novvum</a>, we think this is a massive step in the right direction, but there has been a lot of confusion over how <a href="https://nexus.js.org/">Nexus</a> differs from <a href="https://typegraphql.ml/">TypeGraphQL</a>. This post aims to break down the differences and hopefully clarify the confusion.</p><h3>Code-first: A programmatic API for constructing GraphQL schemas</h3><p>Before we get started, let’s recap why code-first schema development came to be. A popular approach in the Node.js ecosystem for writing a GraphQL server is schema-first or SDL-first. In the schema-first convention, you first define a schema in a Schema Definition Language (SDL) and write resolvers separately. If you were using TypeScript, you would need to define the schema types a second time to be used in your code. Therefore, making a change in the schema requires changes in three different places — the SDL, the resolvers, and the TypeScript types.</p><p>In code-first, the schema is defined <em>in</em> the code, and the SDL gets generated as an <em>artifact</em>. You no longer need to keep track of schema changes in multiple locations! 🎊 Which brings us to Nexus and TypeGraphQL. Both libraries aim to help with code-first schema development, but they differ significantly in how they work.</p><h3>Comparing APIs of GraphQL Nexus and TypeGraphQL 🗒</h3><h4>Types</h4><p>When building a GraphQL schema, a lot of time is spent writing types. Because of this, both Nexus and TypeGraphQL try to make this process as simple as possible.</p><p>Given the following SDL type:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9NrTjz7jWH94dh7S2jqS-A.png" /></figure><p>Here is how it would be defined in TypeGraphql and GraphQL Nexus respectively:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/817/1*8cYgWicNS9zPz_sd52krxQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TEQjRCLll5xlov1T8BvGjA.png" /><figcaption>Left: <strong>TypeGraphQL</strong> | Right: <strong>GraphQL Nexus</strong></figcaption></figure><p>As you can see, the APIs of the two libraries are very different. TypeGraphQL uses classes and relies on an experimental TypeScript feature called <a href="https://www.typescriptlang.org/docs/handbook/decorators.html">decorators</a> (the lines of code that start with the @ symbol). GraphQL Nexus uses native JavaScript syntax.</p><p>With TypeGraphQL, the TypeScript type is simply the User class that we write. It also integrates well with other decorator-based libraries like <a href="https://github.com/typeorm/typeorm">TypeORM</a>, <a href="https://github.com/RobinBuschmann/sequelize-typescript">sequelize-typescript</a> or <a href="https://github.com/szokodiakos/typegoose">Typegoose</a>.</p><p>On the other hand, Nexus auto-generates type-definitions as we develop, and infers them in our code, giving us IDE completion and type error catching out of the box. It also has seamless integration with various databases with the upcoming <a href="https://github.com/prisma/yoga2">Yoga 2</a>. <strong>UPDATE:</strong> <a href="https://www.prisma.io/blog/using-graphql-nexus-with-a-database-pmyl3660ncst">Here</a> is a blog post outlining how to integrate GraphQL Nexus with Prisma.</p><h4>Resolvers</h4><p>Okay, so both libraries are very straightforward when it comes to defining types and eliminating redundant code between the schema definition and TypeScript types. Now, how would we write the resolvers? This is where the two libraries take very different approaches.</p><p>Here is how we would add resolvers for our User type in both libraries:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EUoMvvGBGHf0g5hdcuwePQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u90eCZeVUxQ7dVC4PN3n0A.png" /><figcaption>Left: <strong>TypeGraphQL</strong> | Right: <strong>GraphQL Nexus</strong></figcaption></figure><p>With TypeGraphQL, the resolvers live separately from the type definition, similar to the SDL-first paradigm (<strong>EDIT:</strong> I stand <a href="https://twitter.com/typegraphql/status/1118946711102197760">corrected</a>. It is possible to <a href="https://github.com/19majkel94/type-graphql/blob/v0.17.1/examples/simple-usage/recipe-type.ts#L25-L33">define resolvers in the same location</a> as the type definition). The resolver for the posts field is defined using the @FieldResolver() decorator. You would add fields for the root Query and Mutation by using the @Query(returns =&gt; User) and @Mutation(returns =&gt; User) decorators respectively.</p><p>With GraphQL Nexus, the resolvers are part of the type definition. Another bonus is that we get code completion as we write the resolvers since Nexus is auto-generating the TypeScript types for the resolvers.</p><h3>A Closer Look at the API Design Decisions 🔭</h3><p>I will let the two libraries speak for themselves from their docs.</p><p><a href="https://typegraphql.ml/docs/introduction.html#why"><strong>TypeGraphQL</strong></a><strong>:</strong></p><blockquote>To add a new field to our entity, we have to jump through all the files: modify the entity class, then modify the schema, and finally update the interface. The same goes with inputs or arguments: it’s easy to forget to update one of them or make a mistake with a type. Also, what if we’ve made a typo in a field name? The rename feature (F2) won’t work correctly.</blockquote><blockquote>TypeGraphQL comes to address these issues, based on experience from over a year of developing GraphQL APIs in TypeScript. The main idea is to have only one source of truth by defining the schema using classes and a bit of decorator help. Additional features like dependency injection, validation and auth guards help with common tasks that would normally have to be handled by ourselves.</blockquote><p><a href="https://nexus.js.org/docs/why-graphql-nexus"><strong>GraphQL Nexus</strong></a><strong>:</strong></p><blockquote>The core idea of GraphQL Nexus draws from basing the schema off the SDL — keeping things declarative and simple to understand. It allows you to reference the type names as string literals rather than always needing to import to reference types (you can do that too if you prefer).</blockquote><blockquote>By combining automatic type generation with some of the more powerful features of TypeScript — type merging, conditional types, and type inference, we can know exactly which type names we are referring to and able to use throughout our code. We can know both the parameters and the return type of resolvers without providing any type annotation. It takes a little getting used to, but it ends up leading to a great feedback loop of the types annotating themselves.</blockquote><h3>Summary: Which One to Choose?</h3><p>I hope these examples helped you understand how different the two libraries are. Let’s take a look at some of the tradeoffs of each library.</p><h4><strong>TypeGraphQL</strong></h4><p><strong>Pros:</strong></p><ul><li>Reduces the number of places to keep track of your schema from three to <strong>two or one</strong>. TypeScript types and schema types are combined, but resolvers can either be defined separately or alongside the type definition.</li><li>Has been around longer, so at the time of writing, it has more features like field validation and authorization.</li><li>What you see is what you get when it comes to TypeScript types.</li></ul><p><strong>Cons:</strong></p><ul><li>Works <strong>only with</strong> TypeScript since it relies on <a href="https://github.com/rbuckton/reflect-metadata">metadata reflection</a>.</li><li>The way we annotate types feels redundant when defining fields and resolvers which could lead to silent mismatch errors. More details <a href="https://github.com/19majkel94/type-graphql/issues/296">here</a>.</li></ul><p><strong>NOTE:</strong> If you are currently using TypeGraphQL and it is providing value for you or your team, please <a href="https://opencollective.com/typegraphql">donate</a> to them!</p><h4><strong>GraphQL Nexus</strong></h4><p><strong>Pros:</strong></p><ul><li>Reduces the number of places to keep track of your schema from three to <strong>one</strong>. The schema and TypeScript types and resolvers are in one place.</li><li>Sticks to using standard JavaScript syntax and generates TypeScript types, so it works with both languages.</li><li>Autocompletion and type-checking support for IDEs provide a great developer experience.</li></ul><p><strong>Cons:</strong></p><ul><li>The younger of the two libraries, so it is missing some useful features. Some are on <a href="https://nexus.js.org/docs/future-features">the horizon</a>.</li><li>Since it relies on type generation, the server has to be running while developing. More info <a href="https://github.com/prisma/nexus/issues/77">here</a>.</li></ul><h3>Which one we prefer 🙌</h3><p>At Novvum, we have been using Nexus pretty extensively, and we migrated <a href="https://github.com/Novvum/MarvelQL">MarvelQL</a>, a GraphQL wrapper around the Marvel API, to use it. After also trying TypeGraphQL, we feel that Nexus has been much friendlier to work with, given us more flexibility, and enabled us to move more quickly. However, this is what works well for us, and we understand that all teams operate differently.</p><h3>Let us know what you think ✍️</h3><p>I hope this post proved helpful for those who were not sure of what the differences were between the two libraries. If there is still confusion, please <a href="https://www.novvum.io/contact-us">reach out</a> to us, or you can get a hold of me directly:</p><p>Email — <a href="/service/mailto:rohit@novvum.io">rohit@novvum.io</a></p><p>twitter — <a href="https://twitter.com/rovvum">@rovvum</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7728f26d7e0d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/novvum/typegraphql-and-graphql-nexus-a-look-at-code-first-apis-7728f26d7e0d">TypeGraphQL and GraphQL Nexus — A Look at Code-First APIs</a> was originally published in <a href="https://medium.com/novvum">Novvum</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Companies are Adopting GraphQL]]></title>
            <link>https://medium.com/novvum/why-companies-of-various-sizes-chose-graphql-and-what-they-experienced-7a9d47d06bee?source=rss-f6438fcb514a------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a9d47d06bee</guid>
            <category><![CDATA[surveys]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[graphql]]></category>
            <dc:creator><![CDATA[Rohit Ravikoti]]></dc:creator>
            <pubDate>Tue, 19 Feb 2019 22:24:20 GMT</pubDate>
            <atom:updated>2019-03-21T18:48:07.612Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*na_cSG4IqUVaWPPPG61PFg.png" /></figure><p>This article is the first in a three-part series:</p><ol><li>Introduction: “<a href="https://medium.com/@andriananovvum/introducing-the-graphql-survey-series-insight-from-successful-graphql-adopters-3a83ff0a7e39">Introducing the GraphQL Survey Series: Insight from Successful GraphQL Adopters</a>”</li><li>Part 1: “Why Companies are Adopting GraphQL”</li><li>Part 2: “<a href="https://medium.com/novvum/what-experienced-teams-want-you-to-know-about-migrating-to-graphql-1439f6712a6e">What Experienced Teams Want You to Know about Migrating to GraphQL</a>”</li><li>Part 3: “<a href="https://medium.com/novvum/how-companies-are-using-graphql-and-what-they-migrated-from-844b1d8a164b">How Companies Are Using GraphQL &amp; What They Migrated From</a>”</li></ol><p>Follow us on <a href="https://twitter.com/novvumio?lang=en">Twitter</a> to get notified when the upcoming articles are published.</p><p>As a team of full-stack developers, it’s relatively easy for us to list out the benefits of adopting GraphQL here at Novvum. However, after witnessing the exponential growth of GraphQL recently, we wanted to take the time to gather insights on why companies choose to switch and what outcomes they experience.</p><p>To figure this out, we sent a survey to engineers at companies of different sizes asking them why they chose to use GraphQL and how it lived up to their expectations.</p><blockquote>We found that development velocity was the main reason why companies started using GraphQL, and nearly all of the companies felt GraphQL delivered on their expectations.</blockquote><h3>Survey Overview</h3><p>To measure what attracted companies to GraphQL, we asked them to rank each of these reasons on a scale from 1–6, 1 being the highest and 6 being the lowest.:</p><ul><li><strong>Development Velocity:</strong> How quickly the team can introduce changes and add new features.</li><li><strong>Scalability:</strong> How easily teams can modify their code base to make a change or add something new.</li><li><strong>Modularity:</strong> How organized the team’s infrastructure is.</li><li><strong>Performance:</strong> How quickly the API responds to client requests. <em>GraphQL is not designed to be much more performant than its incumbents, but it does reduce the number of round trips that clients have to make.</em></li><li><strong>Reliability:</strong> How many client errors have resulted from changes made to the API.</li><li><strong>Security:</strong> How secure user information is protected from unauthorized access. <em>GraphQL makes no assumptions regarding security, and it is up to the teams to establish a security protocol that suits their needs.</em></li></ul><p>To measure the benefits teams experienced from using GraphQL, we asked them to indicate how strongly they agree or disagree with the following statements:</p><ul><li>“We were able to speed up our development using GraphQL.”</li><li>“We were able to scale our projects faster with GraphQL.”</li><li>“It was easier to unify our APIs (e.g., Microservices, legacy endpoints, third-party services, etc.).</li><li>“There has been an increase in performance using GraphQL.”</li><li>“Our architecture is more stable, with decreased downtime, and fewer errors.”</li></ul><h3>Results</h3><p>We grouped our survey responses based on team size because a team with 10 engineers is very different than a team with 100 engineers. This allowed us interpret the results by comparing the characteristics of different sized companies.</p><p>Here are our findings for the reasons why teams switch to GraphQL:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V_b_fL2JAuG1f3_-qRm0oQ.png" /></figure><p>Here are the improvements that teams experienced after their switch:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FsHdvTigR4ZGqfmIn6UhKQ.png" /></figure><h4>X-Large Teams (100 or more engineers) and Large Teams (50–100 engineers)</h4><blockquote><strong>Wanted</strong>:<strong> </strong>Faster development speed, better scalability, better modularity</blockquote><blockquote><strong>Got: </strong>Faster development, better scalability</blockquote><p>Companies with engineering teams larger than 50 engineers are usually well-established and have a number of protocols in place to help workflow and productivity amongst team members. The most popular reasons teams of this size chose to use GraphQL was to help them develop software faster, have better scalability, and better modularity. These teams also reported that GraphQL was successful at helping them accomplish these goals.</p><p>GraphQL is primarily designed to improve developer productivity because it lets the client decide what type of data they need and eliminates the back-and-forth communication between frontend and backend engineers. Large companies are able to use these features to their advantage to speed up and improve their development velocity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XDVvgrOP9XYr68yW" /><figcaption>Illustrations compliments of our Junior Engineer, Henry Yang!</figcaption></figure><h4>Medium Teams (10–50 engineers)</h4><blockquote><strong>Wanted</strong>:<strong> </strong>Better modularity, higher performance</blockquote><blockquote><strong>Got: </strong>Faster development, better infrastructure</blockquote><p>Medium sized engineering teams have different characteristics than large or x-large teams. These companies are often in a transition phase from building things quickly with a small number of engineers to getting more organized and growing their team. The most popular reasons these companies started using GraphQL was to increase their modularity and performance. These companies did not experience a huge improvement to their performance after using GraphQL, but were able to speed up their development process and found it easier to unify their APIs.</p><p>GraphQL can help teams unify their existing infrastructure because it provides a way to define a single schema to incorporate different APIs and services. This can help companies of all sizes, but can be particularly useful for medium sized teams who are expanding and would benefit from putting more streamlined processes into place.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UqJBbFyx1M8W8aJA5Pel6w.png" /></figure><h4>Small Teams (10 or less engineers)</h4><blockquote><strong>Wanted: </strong>Faster development, better modularity</blockquote><blockquote><strong>Got: </strong>Faster development, better scalability</blockquote><p>Small engineering teams are often looking to find a product-market-fit and need to be very agile and adapt to change. These characteristics were reflected in our survey results, which concluded that development velocity and modularity were the two most popular reasons that small teams use GraphQL. These teams were successful, and reported quicker development speeds and scalability after switching to GraphQL.</p><p>GraphQL helps teams scale their projects because it provides a lot of flexibility. This helps small teams, which often have changing business goals, to be as adaptable as possible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rzRcAgEOZBNRjQC0EqhTzQ.png" /></figure><h3>Closing Remarks</h3><p>If you are considering switching to GraphQL, these results should be reassuring that companies of all sizes are getting what they hoped for out of the technology. The GraphQL community is growing rapidly, and more engineers are joining all the time. If you are planning on making the switch and need some guidance, <a href="https://www.novvum.io/graphql">we are here to help</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a9d47d06bee" width="1" height="1" alt=""><hr><p><a href="https://medium.com/novvum/why-companies-of-various-sizes-chose-graphql-and-what-they-experienced-7a9d47d06bee">Why Companies are Adopting GraphQL</a> was originally published in <a href="https://medium.com/novvum">Novvum</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[graphql-playground v1.8.8: Introducing Automatic Schema Reload ✨]]></title>
            <link>https://medium.com/novvum/graphql-playground-v1-8-8-introducing-automatic-schema-reload-6c9da4bbd552?source=rss-f6438fcb514a------2</link>
            <guid isPermaLink="false">https://medium.com/p/6c9da4bbd552</guid>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[prisma]]></category>
            <category><![CDATA[graphql-tools]]></category>
            <dc:creator><![CDATA[Rohit Ravikoti]]></dc:creator>
            <pubDate>Thu, 31 Jan 2019 19:12:55 GMT</pubDate>
            <atom:updated>2019-01-31T19:14:26.642Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A1eQh4GlSP0Rjnt_u2VifQ.png" /></figure><h3>graphql-playground v1.8.8: Introducing Schema Polling ✨</h3><p>We would like to introduce the new schema polling feature shipping with version 1.8.8 of <a href="https://github.com/prisma/graphql-playground">graphql-playground</a>! See it in action here:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_JRfQ-bqcLoTqZWLv9O2Fw.gif" /></figure><p>Schema polling automagically updates the embedded documentation in the Playground. That way, you don’t need to hit the reload button any more when introducing a schema change.</p><h4>Settings</h4><p>There are three settings to control the polling behavior:</p><ul><li>schema.polling.enable: to enable/disable the polling feature entirely. Default: true</li><li>schema.polling.endpointFilter: to specify a regex pattern to restrict which url to poll. Default: *localhost*</li><li>schema.polling.interval: to specify frequency of polling in milliseconds. Default: 2000</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C5eRNbhhapN_D4Pn24c9vg.png" /></figure><p>Upgrade your Playground version and try it out yourself, or you could play around with it right now at<em> </em><a href="https://www.graphqlbin.com/v2/new"><em>graphqlbin</em></a>. If you happen to notice the marvel schema we used in the demo and want to check it out, you can <strong><em>find it </em></strong><a href="https://marvelql.com/"><strong><em>here</em></strong></a> 😉.</p><p>This has been a much needed feature for us here at <a href="https://www.novvum.io/">Novvum</a> and a lot of the GraphQL community shared the sentiment, so we made it happen! We hope it proves useful and makes GraphQL developers’ lives a little bit easier 😁.</p><h3>Upcoming Proposals We’re Excited About</h3><p><a href="https://github.com/Novvum/graphql-birdseye">graphql-birdseye</a> 🐦: We put out a <a href="https://github.com/prisma/graphql-playground/issues/935">proposal</a> for adding schema visualization to the Playground. Please check it out and give us your feedback!</p><p><a href="https://github.com/prisma/graphql-playground/issues/936">explorer</a> ☑️: The folks over at <a href="https://www.onegraph.com/">OneGraph</a> built and just recently open sourced an <a href="https://github.com/OneGraph/graphiql-explorer">explorer plugin</a> for GraphiQL and are looking to do the same for Playground. Check out their <a href="https://github.com/prisma/graphql-playground/issues/936">proposal</a> if you’re interested!</p><p>Thanks for reading!</p><p>Check out my other articles:</p><h4><strong>The new SDL view in graphql-playground v1.8.5 —</strong></h4><p><a href="https://www.novvum.io/post/the-new-sdl-view-in-graphql-playground-v1-8-5">https://www.novvum.io/post/the-new-sdl-view-in-graphql-playground-v1-8-5</a></p><h4>Successfully working with open source software</h4><p><a href="https://www.novvum.io/post/successfully-working-with-open-source-software">https://www.novvum.io/post/successfully-working-with-open-source-software</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6c9da4bbd552" width="1" height="1" alt=""><hr><p><a href="https://medium.com/novvum/graphql-playground-v1-8-8-introducing-automatic-schema-reload-6c9da4bbd552">graphql-playground v1.8.8: Introducing Automatic Schema Reload ✨</a> was originally published in <a href="https://medium.com/novvum">Novvum</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The new SDL view in graphql-playground v1.8.5]]></title>
            <link>https://medium.com/novvum/the-new-sdl-view-in-graphql-playground-v1-8-5-17d3a139b86c?source=rss-f6438fcb514a------2</link>
            <guid isPermaLink="false">https://medium.com/p/17d3a139b86c</guid>
            <category><![CDATA[graphql-playground]]></category>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[prisma]]></category>
            <dc:creator><![CDATA[Rohit Ravikoti]]></dc:creator>
            <pubDate>Wed, 16 Jan 2019 16:08:47 GMT</pubDate>
            <atom:updated>2019-01-16T16:08:47.806Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0OHfpufVaEEVP829HBVOlw.png" /></figure><p>Here at <a href="https://www.novvum.io/graphqlconsulting">Novvum</a>, we fell in love with GraphQL two years ago and have been using it to build products for our clients ever since. We attended the 2018 GraphQL summit and were inspired to see all of the awesome companies adopting the technology. The GraphQL community has helped us greatly in delivering robust applications to our clients, and we wanted to repay the favor by doing some contributions of our own:</p><p>The new SDL view in graphql-playground v1.8.5!</p><blockquote>A GraphQL Schema Definition is the most concise way to specify a <a href="https://www.prisma.io/blog/graphql-server-basics-the-schema-ac5e2950214e">GraphQL schema</a>. The syntax is well-defined and <a href="https://github.com/facebook/graphql/pull/90">are part of the official GraphQL specification</a>. Schema Definitions are sometimes referred to as IDL (Interface Definition Language) or SDL (Schema Definition Language).</blockquote><h3>Features</h3><p>Without further ado, let’s jump into some of the features that come with the release!</p><h4>A new side tab</h4><p>To better represent the new functionality, the previous “SCHEMA” tab has been renamed to “DOCS” and a new tab called “SCHEMA”, which displays the SDL view, was added.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dKJ9xLbM9EAWNqetx4TZKQ.png" /></figure><h4>Light and dark themes</h4><p>The SDL view works nicely with both the light and dark themes. By default, playground comes in the dark theme, but you can enable the light theme by going into settings and changing the &quot;editor.theme&quot; property to &quot;light&quot;.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r2Vk-mKUeChlChmHIOCBHQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z4EqP8-CvMvwd_Fuva9B2A.png" /></figure><h4>Export to JSON and GraphQL SDL</h4><p>There are two formats available for downloading the schema. You can download a .json file containing the schema’s introspection response by clicking the “JSON” button and you can download a .graphql file containing the schema’s SDL by clicking the “SDL” button.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4zPnOJCS6lAuCtALNT__cg.gif" /></figure><h4>Enable/disable comments</h4><p>To make comments visible, you can set the &quot;schema.disableComments&quot; property to false in the settings.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MVVPvgSUeKnj15BlRZaAkg.gif" /></figure><h3>This is only the beginning</h3><p>We really enjoyed working on this feature with the <a href="https://www.prisma.io/">Prisma</a> team and we’ve already started working on a few more features coming soon 😄. This is just the start and we are committed and excited to contribute more actively to the GraphQL community!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=17d3a139b86c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/novvum/the-new-sdl-view-in-graphql-playground-v1-8-5-17d3a139b86c">The new SDL view in graphql-playground v1.8.5</a> was originally published in <a href="https://medium.com/novvum">Novvum</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Successfully working with open source software]]></title>
            <link>https://medium.com/novvum/successfully-working-with-open-source-software-8698eb7a909f?source=rss-f6438fcb514a------2</link>
            <guid isPermaLink="false">https://medium.com/p/8698eb7a909f</guid>
            <category><![CDATA[open-source-software]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[guides-and-tutorials]]></category>
            <dc:creator><![CDATA[Rohit Ravikoti]]></dc:creator>
            <pubDate>Sat, 05 Jan 2019 00:12:33 GMT</pubDate>
            <atom:updated>2019-01-05T00:12:33.608Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/670/1*szkKqwlgDY-rov0-qL8X1w.jpeg" /></figure><p>At Novvum, a big part of our success has come from working with open source tools. This paradigm is a distinguishing characteristic of the software industry and it’s like nothing I’ve seen before. Everyone from hobbyists to massive enterprises contribute to open source for FREE and everyone benefits from it.</p><p>As a boutique software agency, we had very little capital to work with when my co-founder, <a href="https://medium.com/@rajinwonderland">Raj</a>, and I first started.</p><blockquote>Having access to high quality software built by experts was a game-changer for us.</blockquote><p>When I first started using open source software, it was overwhelming and sometimes intimidating. It took a lot of time and effort to figure out how to effectively navigate and utilize this vast ecosystem.</p><p>Whether you are trying to build an application or play around with machine learning, you need to find the right tool. This process can be overwhelming due to the sheer number of choices out there. So, how do we filter out the noise and use the tools effectively? Here’s what worked well for me:</p><h3>Find the tools that fit your needs</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/474/1*JwpRF5vmlJ-1ulWiUyOVzA.png" /></figure><p>First, decide which programming language you feel comfortable working with. Some languages are better suited for certain types of projects than others, so it is a good idea to <a href="https://www.fullstackacademy.com/blog/nine-best-programming-languages-to-learn-2018">educate yourself on that</a>.</p><p>Next, do a simple google search and compile a list of options that seem to do what you would like. There are also a number of repositories on GitHub which are named awesome-[topic] which can be found <a href="https://github.com/sindresorhus/awesome">here</a>. They provide a curated list of awesome frameworks, libraries and software around the topic.</p><p>There are also passive ways of coming across new tools from places like Twitter and google news. I’ve found a lot of success coming across new libraries this way and there are many other options. <strong><em>The advantage of using Twitter is that if you follow the right people, they will check the quality of the tool before they post about it which could save you a lot of time.</em></strong> We do not necessarily have to go out looking for libraries — we can setup channels to receive new information as well.</p><h3>Vet your tools</h3><p>One big lesson I’ve learned is that a tool’s description might make it seem like it would to do exactly what is needed, but after further exploration, it is not flexible enough. The way to move forward from there is either to request the author for the new functionality or look for a different tool. Although there is no silver bullet for solving these problems, we can mitigate them early on. Here are a few quick things we could look out for ahead of time:</p><ul><li><strong>Popularity:</strong> There is probably a good reason why so many developers are using the tool. It is a good indicator that it is flexible enough to fit a lot of different use-cases and that the maintainers are responsive enough to support all of these users. It doesn’t mean that one tool which is more popular than another is always the better choice, but it is a good indicator. Different ecosystems have different ways of determining popularity. For instance, Node.js has NPM package downloads and Python has PyPI statistics. GitHub stars are also helpful, but it is not an accurate representation of how many people are using the tool.</li><li><strong>Documentation:</strong> Detailed documentation says a lot about the quality of the project. Just like for any tool, we need an instruction manual on how to use it. I will explain more about how to effectively utilize the documentation in the next section, but at this stage, make sure that the documentation seems detailed enough.</li><li><strong>Maintenance:</strong> Evaluating the quality of the tool by its maintenance is tricky because there is no single rule. Some projects are very actively maintained while others have not been updated in years (we can look at the frequency of commits to the codebase to find this out). Either case might be preferable depending on what the tool does. If the tool implements something fundamental, like algorithms, then chances are it doesn’t need many updates. If it is a framework, then we would probably want it to be updated constantly to fix bugs, improve performance, or add new features.</li><li><strong>Issues:</strong> The issues section on GitHub can give us a lot of insights on what type of problems the tool has and how responsive the maintainers are. They are a good indicator of how flexible the library is.</li></ul><h3>Read the docs</h3><p>Once we have taken the basic first steps of vetting the tools and narrow our choices, it is a good idea to dig into the documentation. We don’t need to read the documentation cover-to-cover, but it helps to skim over the different features that the tool offers to verify that it fits our use case and that it is easy to use. The technique I use here is that I keep my project’s requirements in the back of my mind as I read through the documentation while imagining how I would implement the features for my project. The key thing to note here is that -</p><h4><em>we are not trying to understand the entirety of the library, we just need it for our purpose.</em></h4><p>This process might take a little while and probably not something that can be done in one sitting. There are a couple of different ways to effectively utilize the documentation .</p><ol><li>One way is to go through a portion of the documentation, step away from it, and imagine which of your features you could implement with what you know so far.</li><li>Keep in mind what you need for your project and skim through the documentation to find how the tool might be used. This is something that can be done during a commute (if you are not driving), during a lunch break, or whenever there is some time to spare.</li></ol><p>Going through this process will help find any blatant issues which might not work with the project and it might give you ideas on how to get started.</p><h3>Test them out</h3><p>Reading the documentation can be very helpful, and if the tool seems to fit what you need, you can dig a little deeper. You can try out the tools in your project to see how it actually works. Another option is to make a mini project to test out the tool if it is too time consuming to incorporate into your main project.</p><p>This step is a lot more involved than the others and you may run into a few roadblocks. For instance, the documentation may not give you a full idea of how to implement certain features, so you could always dig into the source code. Peeking under the cover had answered many questions I’d had and it is definitely not as difficult as I first thought.</p><p>The source code may be too complex at times and it is not a plausible solution for understanding how to use the tool. Which brings us to our next section.</p><h3>Reach out</h3><p>There are many times when I’ve run into roadblocks during my implementation where either the documentation was not very clear or I did not have enough of an understanding of the tool. In those cases, it is very helpful to reach out and ask for help. There are a few different options to explore:</p><ul><li><strong>StackOverflow:</strong> A simple google search using the name of the library and the feature you are trying to implement will usually point to a StackOverflow post. It is the go-to place to get answers to issues you may be having. If you are not able to find the right answer, you can always ask a question yourself. Just make sure to be very detailed when asking a question.</li><li><strong>Github issues:</strong> If the feature just does not exist, a good option would be to look through the tool’s GitHub issues. Others might have the same issue. You could also post an issue here and you are more likely to get a timely response from the authors of the library than from StackOverflow.</li><li><strong>Slack channel:</strong> Some OpenSource tools will have a slack workspace for people to discuss issues or ask questions. This would be the best way to get a quick response and your best opportunity to directly ask the people who maintain the tool. It is also a great way to build a relationship with the community since you would be speaking with them directly.</li></ul><h3>Contribute</h3><p>OpenSource software is what it is today because of the tremendous amount of involvement from the community. If you haven’t found a tool that fits exactly what you need, then it is a great opportunity to contribute. The contribution could be something as simple as posting a GitHub issue, or as involved as implementing the feature yourself. This step might feel intimidating at first, but if you’ve gone through all of the above steps to get here, then there is a very valid use-case and other people might also benefit from your work. <a href="https://opensource.guide/how-to-contribute/">Here</a> is a detailed guide on contributing to open source.</p><p>Contributing to an OpenSource software and displaying your work for the whole world to see and scrutinized may be scary for some people. I was certainly one of them. Having contributed anyway, I can say that the people scrutinizing your code are very friendly more often than not and they are just trying to help keep the quality of the tools they are using up to the highest standards. The perspective to take here is that we are all helping each other out to build awesome stuff. So have fun with it!</p><p>If you guys enjoyed reading this article, but feel like you need more details, please post a comment below. I am considering making this into a series where I go into more detail on each of the steps.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8698eb7a909f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/novvum/successfully-working-with-open-source-software-8698eb7a909f">Successfully working with open source software</a> was originally published in <a href="https://medium.com/novvum">Novvum</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GraphQL Summit 2018: A CTO’s Perspective]]></title>
            <link>https://medium.com/novvum/graphql-summit-2018-a-ctos-perspective-bf8f62ce9be9?source=rss-f6438fcb514a------2</link>
            <guid isPermaLink="false">https://medium.com/p/bf8f62ce9be9</guid>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[apollo]]></category>
            <category><![CDATA[developer]]></category>
            <dc:creator><![CDATA[Rohit Ravikoti]]></dc:creator>
            <pubDate>Wed, 26 Dec 2018 20:30:36 GMT</pubDate>
            <atom:updated>2018-12-26T20:37:10.361Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lf85ck3n1y-nVGlP" /></figure><p>This was the first GraphQL Summit I have attended, and I’ve gotta say, I’m impressed! It was held at the Regency Theater in the heart of San Francisco and I heard from the organizers that it was the biggest GraphQL Summit so far.</p><p>There have been a lot of developments in the GraphQL community over the last year and it was amazing to meet the people making it all happen. So, as a CTO of a software agency, I thought I would write this post to highlight some of the exciting things that are happening.</p><h4>The GraphQL foundation was formed in partnership with the Linux Foundation</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4pCrzEyOj64Ifuldh1pZJg.png" /></figure><p>This happened just before the day of the event and is a major milestone for the relatively new technology.</p><blockquote>Through the formation of the GraphQL Foundation, we hope to create a space for our community to work together to help GraphQL become a reliable industry standard by encouraging broad contributions and a shared investment in vendor-neutral events, documentation, tools, and support. This is a natural progression of the work we’ve already done to support the community including hosting regular technical <a href="https://github.com/graphql/graphql-wg">working group</a> meetings, and formalizing an <a href="https://github.com/facebook/graphql/blob/master/CONTRIBUTING.md">RFC process</a> for improvements.</blockquote><h4>Rapid adoption by large companies</h4><figure><a href="https://graphql.org/users/"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Nj5thkoJB9B5iQy2Mfh1ug.png" /></a><figcaption>From <a href="https://graphql.org/users/">https://graphql.org/users/</a></figcaption></figure><p>Companies like GitHub, Intuit, and PayPal have already incorporated GraphQL into their technology. In the last year, GraphQL has seen an exponential growth in adoption by the likes of <a href="https://www.netflix.com/">Netflix</a>, <a href="https://www.airbnb.com/">AirBnB</a>, <a href="https://www.nytimes.com/">New York Times</a>, and many more. It is very reassuring to see tech giants eagerly adopt this technology. Suffice it to say, I think GraphQL is here to stay and is definitely worth the investment.</p><h4>Developer Tooling</h4><p>There is a wide range of tooling available to engineers for building GraphQL APIs and the options are quickly growing. There are fully managed solutions like <a href="https://www.graph.cool/">Graph.cool</a>, <a href="https://hasura.io/">Hasura</a>, <a href="https://www.8base.com/">8base</a>, and <a href="https://aws.amazon.com/appsync/">AWS AppSync</a> which make the process of getting a GraphQL API up and running very easy. You also have tools like <a href="https://www.prisma.io/">Prisma</a>, <a href="https://neo4j.com/">Neo4j</a>, and <a href="https://realm.io/blog/realm-scales-to-the-web/">Realm</a> which allow you to query your database using GraphQL making it easy to incorporate into your API.</p><figure><img alt="Image result for graphql apollo platform" src="https://cdn-images-1.medium.com/proxy/1*6AocNcwqVACrSj-Xf9RyfA.jpeg" /></figure><p>Of course, there is also the <a href="https://www.apollographql.com/platform">Apollo Platform</a> which includes a comprehensive set of tools which help with incremental adoption, development workflows, and production capabilities. The Apollo server and client libraries drastically simplify the process of getting up and running with a GraphQL server and communicating with it from your frontend clients. These libraries work seamlessly with the Apollo Platform to provide some awesome functionality and insights into our API.</p><h4>There is still work to be done</h4><p>Despite all of the tooling available today, getting a scalable and maintainable GraphQL server up and running is still an arduous task. For someone who is new to the ecosystem, it is very difficult to get a handle on the sheer number of tools and libraries available and how they all fit together. Ruby on Rails has done an amazing job with removing the barriers to getting up and running which GraphQL is still lacking. However, the community is moving very rapidly and there are efforts being made to solve this problem.</p><p>I personally look forward to how the community will continue to evolve. There are so many more ideas and possibilities to be explored with this new paradigm and it will continue to dramatically improve developer productivity.</p><p><strong>For more GraphQL content check out:</strong></p><ol><li><a href="https://medium.com/novvum/graphql-the-bakery-an-eli5-explain-like-im-5-for-graphql-de109e8a1f78">GraphQL the Bakery: An ELI5 (Explain like I’m 5) for GraphQL</a></li><li><a href="https://medium.com/novvum/lessons-learned-from-the-graphql-summit-a-students-perspective-dc5a19970858">Lessons Learned from the GraphQL Summit: A Student’s Perspective</a></li><li><a href="https://medium.com/novvum/say-hello-to-marvelql-a-graphql-entry-into-the-marvel-universe-260245200b7d">Say hello to MarvelQL, a GraphQL entry into the Marvel Universe</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bf8f62ce9be9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/novvum/graphql-summit-2018-a-ctos-perspective-bf8f62ce9be9">GraphQL Summit 2018: A CTO’s Perspective</a> was originally published in <a href="https://medium.com/novvum">Novvum</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How we drastically sped up our GraphQL API with Apollo Engine]]></title>
            <link>https://medium.com/novvum/how-we-drastically-sped-up-our-graphql-api-with-apollo-engine-931465538c47?source=rss-f6438fcb514a------2</link>
            <guid isPermaLink="false">https://medium.com/p/931465538c47</guid>
            <category><![CDATA[apollo-client]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[api]]></category>
            <dc:creator><![CDATA[Rohit Ravikoti]]></dc:creator>
            <pubDate>Tue, 30 Oct 2018 23:32:22 GMT</pubDate>
            <atom:updated>2019-02-06T21:52:25.755Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y-K4bpH1IXEua6hcshfESw.jpeg" /></figure><p>In this part of the series, we will take a look at how we went about measuring and speeding up our newly implemented GraphQL API. We did not put much emphasis on optimizing for performance while we were initially building the api because we had no real data on how it would be used in production. The best thing we could do in the beginning was to integrate Apollo Engine to collect the data and later provide us with insights on how we can improve performance.</p><h3>What is Apollo Engine?</h3><p>Apollo Engine is an easy to integrate cloud service that provides deep insights into GraphQL APIs. Engine utilizes GraphQL’s primary advantages to provide features like caching, query execution tracing, and field-level error tracking. To gather insights on how our API is performing, we used the query tracing feature.</p><p>With query tracing, we can see what is slowing down our queries on a per-resolver level:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SEVVRnPSXtjwXEEZ" /></figure><p>This tells us exactly which part of our query is taking the longest to execute and how much time it added to the overall response time.</p><h3>What insights did we gain about our API?</h3><p>We noticed that every query request was initially taking a long time to react the first resolver:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*di9WDj5pK-aB9V9V" /></figure><p>This accounted for an average of ~30% of the wait time of each query. This was because we were authenticating the user and fetching some basic user information from the database each time an api call was made.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TMJE5-fG2izeIRRZ" /></figure><p>This gives us a huge opportunity for us to speed up the response time for every query request hitting our api.</p><h3>The solution</h3><p>Since we were using JSON Web Tokens (JWTs) for authenticating and managing user sessions, we can use one of its key features to our advantage — the payload. We can encode the user data we were previously getting for each api request as part of the JWT payload at the time of generating the auth token. This way, our backend can use this information instead of fetching from the database for each request.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pB7pCavvsRCtT1OL" /></figure><h3>The Results</h3><p>We were able to speed up the response time of every query request by an average of 30%.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SmU8B9kAutQdAw_q" /></figure><p>This was just one simple way we were able to find an opportunity to improve user experience using Apollo Engine. Since then, we were able to identify a few other queries which had very long response times and were able to split them up into smaller, faster queries. Gaining insights like this for REST APIs was very difficult because the implementation is different for each api and would require a lot of time to implement.</p><p><strong>Update:</strong> It is now called <a href="https://www.apollographql.com/docs/">Apollo Platform</a>. There are a lot of new features, so go check it out!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=931465538c47" width="1" height="1" alt=""><hr><p><a href="https://medium.com/novvum/how-we-drastically-sped-up-our-graphql-api-with-apollo-engine-931465538c47">How we drastically sped up our GraphQL API with Apollo Engine</a> was originally published in <a href="https://medium.com/novvum">Novvum</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Services Oriented GraphQL API]]></title>
            <link>https://medium.com/novvum/services-oriented-graphql-api-28eb96b43321?source=rss-f6438fcb514a------2</link>
            <guid isPermaLink="false">https://medium.com/p/28eb96b43321</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[rest-api]]></category>
            <dc:creator><![CDATA[Rohit Ravikoti]]></dc:creator>
            <pubDate>Mon, 06 Aug 2018 22:47:26 GMT</pubDate>
            <atom:updated>2018-08-07T22:57:01.276Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ob7yomiedG_GExNIusMrKg.jpeg" /><figcaption>Image captured by <a href="https://unsplash.com/@picsbydress">Andreas Dress</a></figcaption></figure><p>For our most recent client, we had quite the challenging task of migrating their legacy REST API and MySql database into a GraphQL API. Our client was a startup which was growing rapidly and had evolved over the years, so the majority of their database schema and REST endpoints were obsolete. Given the conditions, we needed to build their backend from the ground up.</p><p>Initially, we thought of going the microservices route by splitting up their database and business logic into individually maintained services. However, after reading <a href="https://m.signalvnoise.com/the-majestic-monolith-29166d022228">DHH’s post about the majestic monolit</a>h, we decided to forego the microservices architecture. There would be too many difficulties regarding how to handle network failure as well as CI/CD for each of those services.</p><p>What we liked most about the microservices architecture is its modularity and the opportunity to work with multiple databases, so even though our codebase is going to be a monolith, it did not have to be tightly coupled. Each service can be its own GraphQL schema connected to its own database and all can be <a href="https://www.apollographql.com/docs/graphql-tools/schema-stitching.html">stitched</a> together by a gateway (the server which exposes our api).</p><blockquote>So, how exactly does the gateway communicate with each of these individual services if they are GraphQL schemas of their own? That’s where GraphQL <a href="https://github.com/graphql-binding/graphql-binding">bindings</a> come in. A binding essentially generates an SDK from a schema provided to it.</blockquote><p><strong>Given the following schema:</strong></p><pre>type Query {<br>	user(where: UserWhereUniqueInput!): User<br>}</pre><p><strong>We can query its binding like so:</strong></p><pre>context.users.query.user({where: { id: userId }})</pre><p>Most of the examples out in the wild for graphql bindings use remote schemas that require network calls. In this case, we are using locally defined schemas. I will make another post on how to accomplish this, but if you can’t wait, you can take a look at the code here:</p><p><a href="https://gitlab.com/novvum/open-source/graphql-services-monorepo-starter">novvum / open-source / graphql-services-monorepo-starter</a></p><p>As a bonus, we can use <a href="https://github.com/graphql-cli/graphql-cli">graphql-cli</a> to automatically generate the binding and typescript types from our schema definition. For our databases, we used <a href="https://www.prisma.io/">prisma</a> since it already comes with bindings. This architecture also gives us some great possibilities when it comes to integrating third party services and unifying our API.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=28eb96b43321" width="1" height="1" alt=""><hr><p><a href="https://medium.com/novvum/services-oriented-graphql-api-28eb96b43321">Services Oriented GraphQL API</a> was originally published in <a href="https://medium.com/novvum">Novvum</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>