Our Blog Posts

What happens when the technology behind your product depends on what users want, but what users want depends on what the technology can do? This blog post is about what product R&D looks like when developer experience depends on the underlying tech—and vice versa.

This blog post is about the 25 days Mark Gritter spent in the depths of despair and the details of Go memory management to save us from having to rewrite our client in Rust. This post details Mark's lessons and main takeways.

Recently, we finally had our first in-person meeting! It took nontrivial finagling to figure out how to do it in a budget-friendly, COVID-safe way, so here’s a post about how it went down.We intend for this post to be helpful for anyone trying to figure out how to get their team together safely during the pandemic.

In this post, we’ll talk about how observability tools are really about system understanding, how logs, metrics, and traces are the implementation strategy, and what it might look like to raise the level of abstraction.

In this post, Jean Yang talks about the dream of one-click observability that we’re building toward, why a GraphQL-only world would certainly make that dream easier, and why the Software Heterogeneity Problem means that building on GraphQL alone is not going to be enough.

This blog post, in addition to being a love letter to offices, is about what life was like in our physical office, our rough transition to Slack and Zoom, and how we found our groove after “moving in” to our virtual office, which we’ve built using a platform called ohyay.

In this blog post, Jean Yang talks about why there aren't more "deep tech" developer tools startups. Jean debunks myths about lack of budget or developer buying power—and focuses on how we can all work together to use deeply technical solutions to solve major developer problems.

In this post, Mark Gritter talks about our setup and experience monitoring Akita’s own services using Akita. Mark shows how we set up Akita, how we automatically generate API models from our staging and production environments, and the questions I’m able to answer from our traffic.

This post is about how, if we turn specs on their head, they can help us through both automation and complexity. Jean Yang talks about what specs are, why they’re good, where they fall down, and how inferring specs is the way to scale automated reasoning about complex systems.

A few weeks ago, Jean Yang Tweeted about how there are two kinds of developer tools, ones that abstract over functionality and ones that reveal complexity, and that we need to think about developer experience differently for the two. This post is an elaboration of that Tweet thread.

Mark Gritter talks about the diagrams that developers are constructing in their heads to answer these questions, explains why it’s hard to automate the construction of these diagrams using most tools, shows how passively modeling API traffic makes it possible to answer these questions in a low-friction, low-risk way, and talks about what he's been working on at Akita.

In this post, Jean Yang explains why we need a new kind of software analysis that works across services and APIs, gives an overview of other approaches for understanding software, and shows how building API behavior models from traffic is The Way.

What does the Martian Climate Orbiter have in common with modern software systems? Find out in this post, where we’ll show our new UI for helping developers catch breaking changes. We’ll talk about what kinds of changes Akita helps flag and explain how Akita catches breaking changes by passively modeling API traffic.

In this post, Jean Yang talks about why software engineering as we know it is dead and how we need to fill the gaps in developer experience. This post is an elaboration of a Taylor Swift themed talk Jean recently gave at DevX Conf.

This is a guest post by Akita user Bruno Félix, CTO at Waterdog. This post explores how to generate and compare OpenAPI specs for a service just by analyzing the network traffic without touching the application’s code. We’ll focus on integrating with Kubernetes, the most popular container orchestration system in use today.

In this post, Kevin Ku covers a couple of advanced packet filtering topic. Kevin first talks about how to filter packets with packet capture filters (cBPF). Then Kevin provides a quick start on how to use tcpdump under the common scenarios you might encounter with docker containers.

The Akita agent works by passively monitoring API traffic, so that we don’t need to be on the data path or add any performance overhead. But the trade-off is that pointing Akita at the right traffic can be error-prone. Mark Gritter talks about the latest addition to our CLI: network diagnostics to smoother Akita setup.

tcpdump and Wireshark are great, but what if you want to programmatically analyze network traffic? In this post, Kevin Ku walks through how to use GoPacket to programmatically capture and analyze network traffic.

In this blog post, Mark Gritter talks about why API performance matters, how tracking performance at the endpoint level can help, and how this looks with Akita’s new endpoint performance feature.

In this blog post, Cole Schlesinger gives an overview of how Akita works, what’s hard about getting Akita to work with non-network integration tests, and how our test client integration works. This post may be interesting to anyone looking to add request logging or pre- or post-processing to REST framework test clients.

This blog post is about our vision for API observability, why inferring models of API behavior is the way to achieve this vision, and the work that we need to do to get from here to there.

From the beginning, our goal at Akita has been to make software more robust and trustworthy. This past year, our learnings led us to significantly shift our strategy for how to get there. Here are the lessons we learned that led to our pivot, that may be helpful to anyone else who thinks a lot about how programming tools get adopted.

As a developer who has also worked in devops, Kevin Ku understands the importance of finding and fixing bugs early in the development cycle. In this blog post, Kevin shows a bug that’s hard to catch with source diffs, linters, or static analysis. He shows how to use Akita to catch this bug and explains how Akita works under the hood.

This blog post is about a new feature that we built at Akita after Chris Corcoran spent a painful couple of days figuring out how to script against Notion. After Chris's experience trying to learn the undocumented Notion API, we decided to automate the process of learning web APIs so that nobody would have to suffer like this again.

Akita operates by watching network traffic. Akita user Sébastien Portebois wanted to try Akita out on CI tests, but the problem is that the tests don’t actually generate network traffic. This post describes a workaround for our Flask integration tests, based on automatically creating real HTTP traffic from the tests, and sending it to a dummy server.

In our last blog post, we talked about how to catch cross-service bugs by watching API traffic. In this blog post, we show specifically how checking data formats across APIs can catch some nasty bugs.

In this blog post, we’ll show you a bug that slips through the cracks today, explain why it’s nobody’s fault, and show you how we diff API behaviors to catch bugs (while generating API specs along the way!!).

It's no secret that APIs are a blessing and a curse. In this post, Jean Yang talks about our approach for taming this complexity.