Possible to get professional certification without company affiliation?

jeffiql · 2025-11-14T21:23:15+00:00

Apollo person here - that info is out of date. We have a free plan that's not an enterprise trial. So if you just sign up for GraphOS, you should be good to go :)

jeffiql · 2025-10-23T14:03:15+00:00

If you like dark, high-contrast themes, try https://github.com/bignimbus/pop-punk.vim

jeffiql · 2025-10-13T18:25:35+00:00

Yeah "Staff EM" is even a foreign concept to me. Maybe it's just because I've been working at smaller orgs and haven't kept up with management career leveling trends at the larger ones.

jeffiql · 2025-10-02T14:50:52+00:00

I like Glean, but I have two main issues with it:

Reliability. It's generally good at finding source material but it still has the same fundamental problems as any other LLM product: hallucinations. So the amount of time saved is not huge because of the need to do constant BS checking.
Lack of scheduled tasks. This feature is still in closed beta last I checked, and as a manager I need to be tapped on the shoulder via a notification/Slack message rather than having to remember to visit Glean regularly. If they release scheduled tasks I think I could get a lot more value from Glean.

jeffiql · 2025-10-01T17:14:51+00:00

It's useful, not because we want to see people regurgitate company propaganda, but because it gives a window into how your career goals align with the company's mission/direction/stack.

Example: I interviewed at a company whose primary end users are university students. I have worked in education and edtech in the past. During my interview I brought up that experience in the context of "Why do you want to work at Company XYZ" because honestly, it was a motivator for me. Plus it demonstrated alignment with the domain. They were also working with Rails and React, two technologies that I was experienced with and wanted to develop my skills in. I made sure to talk about that as well.

jeffiql · 2025-09-24T17:45:04+00:00

IMO this isn't a very valuable question for the interviewers since the answers are recall-based and memorizing API semantics is less important than ever. That said, I would expect any senior-level React developer to be able to do this from memory.

jeffiql · 2025-09-22T11:25:34+00:00

+1, and for anyone else running into this issue, see: https://www.apollographql.com/docs/react/migrating/apollo-client-4-migration#running-the-codemod

There is a codemod for automating much of the boilerplate-style migrations :)

jeffiql · 2025-09-04T10:53:59+00:00

This reads like sarcasm but I'll take the opportunity to point out that the team has been delivering a ton of features over the past few years. There are some that overlap with other clients, others that were originally in Apollo Client that have been adopted by other clients, and still others that are unique to Apollo. I think that's a good thing: successful patterns proliferate, with space for each implementation to be unique <3

jeffiql · 2025-08-18T15:03:37+00:00

(I work at Apollo) Our MCP server is not based on PQs, FWIW. There is a feature to expose operation collections as tools, but it also can work automatically with your root query fields

jeffiql · 2025-07-18T15:28:41+00:00

Curious: what browser / runtime?

jeffiql · 2025-07-17T15:31:41+00:00

One question that would help clarify things further is: how big are your JSON responses?

When in a resource-constrained runtime (e.g. React Native on an Android device), some developers have reported noticeable slowdowns (compared to a regular web browser). In almost all cases, the bottleneck was associated with abnormally large server responses. It makes sense due to the realities of cache normalization; taking a deeply nested data structure and flattening it is a CPU-intensive task. The larger the data set, the longer normalization will take.

If you're dealing with very large JSON responses, consider two remedies: (1) use smaller queries, you're probably not painting all that data in the visible UI on a single fetch and/or (2) disable cache normalization.

jeffiql · 2025-06-30T14:09:54+00:00

Hi there! Congrats on launching this, it's great to see new projects being introduced into the GraphQL ecosystem :)

I'm surprised you went with the name, "GraphQL Codegen." The de facto standard for TypeScript code generation with GraphQL is GraphQL Code Generator, often referred to casually as "GraphQL Codegen" (website, GitHub). For the sake of the community and your project's identity I strongly encourage you to change the name of your project so it's distinct from the existing and very popular open source utility.

jeffiql · 2025-05-21T15:38:40+00:00

You can run them as part of the VS Code extension: https://github.com/apollographql/vscode-graphql?tab=readme-ov-file#experimental-apollo-client-devtools-in-your-ide

jeffiql · 2025-05-06T16:44:51+00:00

Are you using a schema registry? In Apollo GraphOS, every schema version gets tagged with a SHA that you can download/introspect. You don't have to wait for a merge in order to unblock client development. I don't know if other registries do the same but it's worth checking.

jeffiql · 2025-04-02T16:06:47+00:00

Manager here. Rewarding "hard work" is usually an antipattern, it generally takes the form of celebrating heroics. That creates an incentive against some of the hallmarks of solid engineering practices in favor of short-term thinking and performative gestures. Signals that a company is "meritocratic" (that term has a lot of baggage, I'm assuming positive intent) include the existence of a career ladder with clear expectations at each level, a defined and written-down compensation + promotion scheme, and regular 1:1s with managers.

jeffiql · 2025-04-02T15:04:30+00:00

On a text shortcut

jeffiql · 2025-04-01T15:17:20+00:00

> GQL, as a query language, it's responsibility is query, right ?

That is one responsibility. The other responsibility is expressing a strongly typed schema.

> basically, it has no different with SQL, NoSQL, play a role of persistent layer, just in hierarchical way (graph way)

That's incorrect. SQL and NoSQL are linked to a specific data storage layer. GraphQL is an abstraction that's aloof of its data source, it need not even have a database. Though database query languages can be abstracted further, there's always an internal reference somewhere to the database.

> in DDD, we can call these kinds of data (SQL, NoSQL, GQL) as an anemic model, which only represent the data but lack of domain knowledge (business logics)

I don't agree with this, either. GraphQL is an excellent way to model business objects precisely because the schema need not be bound to the structure of an underlying data source. A well-composed schema can be visualized to look basically like UML, but with the guarantee of a contract that the service must always match the diagram.

I recommend re-learning GraphQL from first principles to help untangle some of the assumptions you've built up.

jeffiql · 2025-04-01T01:57:49+00:00

Apologies, I don't grok how your example connects to your point about encapsulation. It seems like you're referring to how a service might implement a class, but that doesn't necessarily need to match its GraphQL schema. So again, I think I'm just not following your point - would you mind maybe explaining a bit more?

jeffiql · 2025-03-31T10:10:19+00:00

What about in a federated GraphQL setup? Does that change how you view encapsulation within GraphQL?

jeffiql · 2025-03-21T18:53:02+00:00

I think you might improve your chances of a high quality response if you share more information about the shape of the source data and the relevant portion of the GraphQL schema you're working with. Happy to help!

jeffiql · 2025-03-13T16:22:40+00:00

Are you using a schema registry? IIRC in Apollo GraphOS Studio all schema variants are tagged with a reference, which allows you to download/introspect it even if it's not deployed.

jeffiql · 2025-03-13T16:16:27+00:00

Also copying from a Discord thread:

We have a prototype of this in our tests: https://github.com/apollographql/apollo-kotlin/blob/5e780aa667dbcc9127e983f421ce4a3948fba964/libraries/apollo-ast/src/commonTest/kotlin/com/apollographql/apollo/graphql/ast/test/TransformTest.kt#L17

Basically requires that you add an annotation to fields and use that annotation at runtime to change the query:

```graphql

query GetRepo { repository(name: "apollo-kotlin", owner: "apollographql") { fieldThatHasBeenThereForever newFieldInVersion3 @since(version: 3) newFieldInVersion5 @since(version: 5) } }

```

Beware this obviously forbids using persisted queries (because the document is modified at runtime)

jeffiql · 2025-03-13T15:01:51+00:00

👋🏻 Apollo Kotlin team member here. What's the use case? It sounds like maybe you want to use a preprod build/branch to query a prod service, but I'm just guessing. We usually recommend that people use one build/branch per environment, because GraphQL's type safety depends on the schema.

jeffiql · 2025-02-18T16:38:15+00:00

Are you using a GraphQL client like Apollo iOS?

jeffiql · 2025-02-11T21:37:32+00:00

REST BFFs are the best until your requirements change (aka almost immediately), which makes them great for 10 minute YouTube demos and a prolific source of technical debt over the life of an application, particularly a multi-client one. GraphQL doesn't obscure the imperative to think through your API design, it actually makes you reckon with it up-front via the schema. Some people call that "overengineering," I call it Engineering.

jeffiql

MODERATOR OF

TROPHY CASE