What is the difference between monitoring and observability?
Monitoring answers questions you thought of in advance: is the service up, is the disk full, how many requests came in. Observability is about the questions you only think of during an incident, and which you then need to be able to answer without writing new code. The difference lies mainly in the richness of what you record: enough context per event to filter afterwards on something you had no dashboard for beforehand. In practice you need both, and most organisations have the first but not the second.
Which four signals do you mean exactly?
Latency, error rate, traffic and saturation. Together they describe whether your service is doing its job and whether it is running at its limit. The appeal is that the first three are about your user, not your infrastructure. A disk that is eighty per cent full is not a problem; a latency that doubles is. Alerting on the first category leads to nights when nothing was wrong, and that is exactly how alert fatigue arises.
Will you replace our current platform?
Usually not, and we rarely recommend it. Grafana, Datadog, Elastic, New Relic and your cloud provider's services do what they're meant to do; the problem almost always lies in what your software feeds into them. That's the side we set up. If you do want to switch, instrumenting through OpenTelemetry is the sensible order: it makes your telemetry independent of the platform, so the move afterwards is a matter of configuration rather than a second rebuild.
What does storage cost, and how do we keep it under control?
The observability bill comes almost entirely down to how much you keep and for how long. The approach that holds up is to choose per type of data. Metrics are small and can be kept for a long time, because they show you how something develops over months. Log lines are large and mostly useful in the days that follow. Traces are the largest, and a sample is enough, with the rule that anything that fails is kept in full. Together, those three choices make a difference of many times over in practice, without you giving anything up.
Does this also work if our software doesn't consist of separate services?
Yes, and it's simpler. With a single application, the gain lies less in tracing and more in bringing together what already exists: metrics per function, log lines with enough context to filter on, and alerting tied to the service. We set that up in the same way, only the step across system boundaries falls away. If you later grow into multiple services, the foundation is already in place.
How does this fit with our security?
The same logging that helps you during an outage is what you need to reconstruct what happened after a security incident. That isn't an extra project but the same work with a second payoff, and it connects directly to
vulnerability management. We do pay attention to what ends up in the log lines: personal data and secrets don't belong there, and that's a choice you make during instrumentation rather than fixing it afterwards.
Who needs to pick this up on our side?
Someone who is on call when something breaks. Observability set up by someone other than the people who use it is rarely used: the dashboards then answer the questions the builder had, not the questions that come up at three in the morning. That's why we work together with your own developers and operations staff, and the handover is part of the engagement, not an appendix at the end.
How quickly will we notice a difference?
The first gains usually come from bringing together what already exists and cleaning up the alerting; you'll notice that within the first sprints. Tracing across system boundaries requires changes to the software and takes longer, service by service. We deliberately start with the service where the most time is lost, so the first delivery is also the most noticeable one.
Can you also do this for off-the-shelf software?
For the part we can reach, yes: traffic coming in and going out, availability, call response times, and the queues in between. What happens inside such a package depends on what the vendor makes available. In practice that's enough to determine whether a problem lies with you or with them, which is usually exactly the question you want to be able to answer.
What is an error budget and do we need one?
An error budget is the margin between your target and one hundred per cent. If you agree that 99.9 per cent of requests succeed, that last tenth of a per cent is your budget. As long as it isn't used up, new functionality can ship; once it runs out, attention goes to stability first. That's useful as soon as there's debate between pushing ahead with new features and fixing things, and unnecessary as long as there's no such debate. We recommend it for the third variant, not the first.
Do you work with OpenTelemetry or with something from a vendor?
OpenTelemetry by default. It's the open standard for metrics, logs and traces, and almost every platform can read it. The advantage is that the instrumentation in your code isn't tied to a vendor: if you switch platforms, you simply point the stream somewhere else. Only if you're already deep into a vendor-specific approach and have no plans to switch might it make more sense to keep building on that.