Build
Connect & operate
Design & teams
Start hereScope a build in one callBring a spec, a wireframe, or a paragraph. You leave with an architecture, a timeline, and a number.Book a scoping call
AI software
LLM & data systems
Vibe coding
Ready to ship?Put AI where the work isAgents, RAG, and private LLMs wired into the systems your team already uses — not a chatbot bolted to a homepage.Discuss an AI project
Domain firstWe learn your workflow before we model itRegulated, operational, or high-volume — the constraints belong in the schema, not in a training doc.Talk about your domain
Plan smarterEstimate before you commitCost ranges, scope templates, and the questions we ask in discovery — free, no form.Open the cost calculator
Real conversationsTalk with a technical leadNo SDR, no discovery gauntlet. The person on the call is the one who scopes the build.Book a call
Open-Source Observability · pinpoint-apm

pinpoint

Pinpoint is an open-source Application Performance Management (APM) tool designed for monitoring and tracing transactions across large-scale distributed systems. It provides real-time visibility into application topology, code-level transaction details, and performance metrics with minimal overhead (~3% resource usage).

Source: GitHub — github.com/pinpoint-apm/pinpoint
13.8k
GitHub stars
3.8k
Forks
Java
Primary language
Apache-2.0
License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

FieldValue
Repositorypinpoint-apm/pinpoint
Ownerpinpoint-apm
Primary languageJava
LicenseApache-2.0 — OSI-approved
Stars13.8k
Forks3.8k
Open issues531
Latest releasev3.1.0 (2026-05-20)
Last updated2026-07-08
Sourcehttps://github.com/pinpoint-apm/pinpoint

What pinpoint is

Pinpoint is a Java-based APM platform inspired by Google Dapper that uses bytecode instrumentation to trace transactions across distributed systems without code changes. It supports JDK 8+, a wide range of frameworks (Spring, Tomcat, Jetty, etc.), RPC protocols (Thrift, gRPC, Dubbo), messaging systems (Kafka, RabbitMQ, ActiveMQ), and databases (MySQL, PostgreSQL, Oracle, etc.), with additional C-based agents for PHP and Python.

Quickstart

Get the pinpoint source

Clone the repository and explore it locally.

terminalbash
git clone https://github.com/pinpoint-apm/pinpoint.gitcd pinpoint# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Large-scale microservices topology mapping

Automatically visualize service dependency graphs and interdependencies without manual configuration, enabling quick identification of architectural bottlenecks and communication patterns across dozens or hundreds of services.

Real-time transaction tracing and debugging

Gain end-to-end visibility into individual request flows across multiple services with call stack inspection, enabling rapid diagnosis of latency issues and failure points at the code level without modifying application code.

Performance baseline monitoring for Java/Spring applications

Monitor active threads, GC behavior, JVM metrics, and URI-level performance statistics in real-time to detect anomalies, resource exhaustion, and performance regressions as they occur.

Implementation considerations

  • Agent deployment requires JVM parameter injection (no code changes required); verify compatibility with application startup scripts and container orchestration before production rollout.
  • Backend storage uses HBase; plan for cluster setup, data retention policies, and backup strategy. Kubernetes deployment reference available at pinpoint-kubernetes repository.
  • Wide plugin support, but verify your exact framework versions and custom libraries have instrumentation; check plugin repository for coverage gaps.
  • Sampling and filtering configuration critical at scale to manage storage and query performance; start conservative and tune based on baseline metrics.
  • Transaction ID correlation across services relies on header propagation; ensure your HTTP/RPC frameworks and custom code preserve trace context.

When to avoid it — and what to weigh

  • Serverless or event-driven architectures — Pinpoint's agent-based instrumentation model is designed for long-running processes. Deployment on AWS Lambda, Azure Functions, or similar short-lived compute may not fit the monitoring lifecycle or add significant cold-start overhead.
  • Non-Java backend stack as primary focus — While Pinpoint supports PHP and Python via a separate C agent, primary development and plugin ecosystem target Java. Mixed-stack environments where Java is not the dominant runtime may face incomplete instrumentation and plugin gaps.
  • Highly constrained resource environments — Although overhead is claimed at ~3%, agent-based instrumentation in memory-constrained containers or edge deployments may be problematic. Evaluate actual footprint for embedded or IoT scenarios.
  • Requirement for SaaS-managed solution — Pinpoint is self-hosted only. Organizations without infrastructure for backend deployment, HBase storage, and collector/UI maintenance should consider SaaS alternatives (Datadog, New Relic, etc.).

License & commercial use

Licensed under Apache License 2.0 (Apache-2.0), a permissive OSI-approved license permitting commercial use, modification, and distribution with minimal restrictions (requires license and copyright notice).

Apache-2.0 clearly permits commercial deployment and use. No proprietary restrictions or commercial licensing fees imposed by the project. Organizations must respect the license terms (include license notice, document changes) but face no usage-based fees or restrictions on internal or customer-facing use.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

SignalAssessment
MaintenanceActive
DocumentationAdequate
License clarityClear
Deployment complexityModerate
DEV.co fitGood
Assessment confidenceHigh
Security considerations

Project does not publish security advisories or policies in provided data. Agent-based instrumentation runs with application JVM privileges; verify bytecode injection risk in your threat model. Network communication between agents and collector should use TLS in production; verify configuration options. No security audit or certification claims stated. Conduct security review of plugin implementations for your critical frameworks before production.

Alternatives to consider

Jaeger (open-source distributed tracing)

Cloud-native, Kubernetes-friendly, supports OpenTelemetry standard. Better for polyglot architectures but requires explicit instrumentation code; lower overhead in serverless.

Datadog APM

SaaS-managed, broader platform (logs, metrics, traces), lower operational overhead. Higher cost, vendor lock-in; no self-hosted option.

New Relic One APM

SaaS offering with auto-instrumentation agents for Java. Simpler ops, broader feature set (infrastructure monitoring, NRQL), but requires cloud account and subscription fees.

Software development agency

Build on pinpoint with DEV.co software developers

Pinpoint offers powerful, self-hosted distributed tracing with minimal instrumentation effort. Evaluate deployment requirements, HBase infrastructure planning, and plugin compatibility for your stack. Contact our DevOps team for proof-of-concept guidance.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

Related on DEV.co

Explore the category and the services that help you build with it.

pinpoint FAQ

Does Pinpoint require code changes to existing applications?
No. Pinpoint uses bytecode instrumentation via JVM agent parameter. Deploy the agent JAR and pass a single JVM flag (-javaagent); existing application code remains unchanged. Agent auto-discovers supported frameworks and libraries.
What is the storage backend and scaling model?
Pinpoint uses HBase for time-series data storage. You provision and manage the HBase cluster. Scaling requires HBase cluster expansion. For managed alternatives, consider Kubernetes-based Pinpoint deployment or SaaS competitors.
Can I monitor non-Java applications with Pinpoint?
Pinpoint provides C-based agents for PHP and Python (pinpoint-c-agent repository), but the core ecosystem, plugins, and maintenance focus Java. Mixed-stack environments may have incomplete instrumentation; evaluate plugin coverage for your stack.
What is the performance overhead?
Documentation claims approximately 3% increase in resource usage. Actual overhead depends on transaction volume, sampling configuration, and instrumentation depth. Conduct load testing with your production workload profile before deploying.

From evaluation to production software

DEV.co builds and maintains open-source observability systems for startups through enterprises. If pinpoint fits your architecture, our custom software development services cover implementation, migration, and the long tail of maintenance.

Ready to deploy APM for your Java microservices?

Pinpoint offers powerful, self-hosted distributed tracing with minimal instrumentation effort. Evaluate deployment requirements, HBase infrastructure planning, and plugin compatibility for your stack. Contact our DevOps team for proof-of-concept guidance.