Our Blog Posts

We’ll go through a quick primer on latency metrics, talk about why you might want to look at p95, p99, p99.9 in addition to p90, and walk through what being able to explore across latency metrics in Akita means for your app. This post may be helpful for anyone trying to make sense of latency metrics for their own performance monitoring.

Jean Yang posits that if you wanted just one tool to tell you about your bugs that mattered, an API monitoring tool is a good candidate. But not the API monitoring tools of today: we need to see some innovation in this space!

In this blog post, Lauren Rother introduces our newest feature: a custom time picker for the Metrics & Errors page.

I’ve been pleasantly surprised at how much our team has been able to get to know each other and stay connected virtually! In this post, we share some of our favorite virtual routines, traditions, and memories. We'd love to hear yours.

In this blog post, we introduce our new and improved API model page, the latest milestone in our journey to help developers like you understand the behavior of your production systems.

In this blog post, David Jaiyeola from Shuttlers talks about how they were struggling to debug payment issues and how adopting Akita for API monitoring helped them quickly address the problem.

If you've ever wondered why things on the Internet don't "just work," you may be interested in Mark Gritter's blog post about the fictions associated with the HTTP protocol and JSON data format.

Jean Yang talks about how system understanding has become a necessary part of developer toolboxes, where existing solutions are leaving behind most developers, and the approach we’re taking at Akita.

We’re excited to show you our new API overview page.

Jean Yang talks about where RTFM culture came from, how she came to realize that RTFM culture lurks in developer tools today, and how “hardcore” dev tools could do well to outgrow RFTM culture and embrace a more user-focused, service-oriented attitude.

Head of Product Lauren Rother tells the story of a long-ignored bug that finally came to be fixed while she was Product Manager at a now-public cloud infrastructure startup. She talks about why fixing it was so hard, how if they had a tool like Akita they could’ve avoided a lot of pain, and what she's excited to build at Akita to help fix that pain for others.

This blog post is about why understanding prod means watching traffic, how traffic-based solutions have been working well for security, where traffic-based solutions fall short for developers today, and one vision for the future of drop-in solutions.

In this post, Jean Yang talks about why it’s so hard to catch bugs you don’t know about, what a solution needs to look like, and how we came to build per-endpoint alerting at Akita to solve this problem.

This is a guest post by Akita user Guilherme Mori, CTO of Brazilian clean energy company zMatch, about how moving fast when you have to live with past (software) decisions.

Jean Yang writes about why there often needs to be so many meetings, why API catalogs remain out-of-reach for most software teams, and how API maps help reduce meetings for “99% developer” teams.

In this post, Mark Gritter talks about common issues he's seen among developers who have become responsible for maintaining other people’s code in production. He talks about how API observability, especially as we are working on it at Akita, addresses the issue of running legacy services.

We’re excited to release our OpenAPI Spec Generator Chrome extension. With this extension, you can automatically generate an OpenAPI spec for any website by simply browsing.

In this post, Mark Gritter identifies the problems people are missing with purely service-level alerting, backs this up with real data, and shows how API observability can make things better.

This is a guest post by Guilherme Mori, CTO at zMatch, about his experience using Akita to quickly understand his API endpoints pre-launch and to easily monitor them post-launch.

As we’ve gotten more confident about our product’s value, we have been shifting from prototyping to polishing. One of the biggest things that’s changing is how we’re approaching team construction. This blog post is about how we’re planning to grow our team—and why now is a great time to join us.

This April 1, we’re excited to introduce our newest product: Akita Logchain.

This is a guest post by Nick Scheiblauer, a Senior Engineering Manager on the backend team at Flickr. Nick writes about the plugin he wrote to use Akita with their "RESTish" legacy API format.

Our newest team member Brennan Moore talks about his experiences keeping the site running while moving fast with resource-constrained engineering teams—and how that led him to work on building the future of API observability full-time.

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.

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.

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!!).