Our Blog Posts

Versilis has put together a demo so you can now connect to Akita to see the good, the bad, and the ugly of an API before you run Akita on your own system. In this post, Versilis talks about what he built and how.

The Akita Docker Desktop extension is now officially in beta! Read on to learn more about our journey from alpha to beta and the problems we’ve solved along the way.

Kubernetes users can now use our injector to run Akita as a sidecar by running a single command. Versilis Tyson talks about this new capability.

We're excited to introduce to the world Aki: our ChatGPT-powered assistant. In this blog post, Paul Russo talks about the motivation for our new friend, show what he can do, and talk about some of the limitations people will need to watch out for with alpha-Aki.

We’re excited to announce our beta is now open to everyone and would love for you to try it out. With the beta, it’s possible to set up Akita within 30 minutes to see what API endpoints are in use, which endpoints are slow, and which endpoints are throwing errors. 

Mark Gritter discusses what health checks are, why and when they are meaningful, how to build good ones, and what some of the alternatives to health checks are. Mark makes the case for why you want to monitor your health checks.

We talk about why it’s so hard to see what’s wrong with your app, Akita’s approach, and what you now get with the launch of our new Metrics & Errors page.

We talk about what we're working on in 2023 to make it faster and easier for developers to understand their app's production behavior.

With the Akita API Docker extension, you can use Docker Desktop to see your API endpoints, which ones might be slow, and which ones are throwing errors—in just minutes.

Jeremy Ruppel from Flickr talks about the difficulties of adopting tooling in a system with any amount of legacy code, the monitoring and observability challenges they’ve encountered during his charge at Flickr, and the straightforward integration process they had with Akita.

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.

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.

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.

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.

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, 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.

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.

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.

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