ArangoGraph Reviews

My main use case for ArangoGraph is anomaly detection (UEBA). On our backend team, we ingest access/security  millions of logs through Kafka using Python services, parse them, and dump them into ArangoGraph. We store the data in Arango like collections USER, LOCATION, URL then edges among them like USER_ACCESS_URL, USER_ACCESS_LOCATION. 

Our detection jobs run AQL queries to find anomalies, such as impossible travel and access to risky countries. We then give each user a risk score from 0 to 100.

ArangoGraph keeps users, locations, and urls in one place. It is easy to detect  anomaly behavoiurs. And writing AQL is like writing code in Python. 

One standout feature of ArangoGraph compared to other databases is its native multi-model support.

I choose ArangoGraph over other databases because the biggest driver for us was the native multi-model support. Before this, we were considering keeping JSON logs in a standard document store and syncing the relationship data into a separate graph database such as Neo4j. Managing that dual-write architecture in production was a nightmare. With ArangoGraph, we get a document store and a graph database in one instance, and since we run our workload on GCP, having ArangoGraph handle the managed cloud deployment, sharding, and automated backup keeps our DevOps workload low.

The best features ArangoGraph offers include its native multi-model engine that combines documents, graphs, and key-value storage, eliminating polyglot persistence and dual writes. AQL is incredibly clean and intuitive, allowing seamless handling of aggregation, graph traversal, and joins without switching between SQL and MongoDB queries. Another feature I appreciate is ArangoSearch, an integrated full-text search engine that allows BM25 ranking, fuzzy search, and text matching alongside graph queries without managing a separate Elasticsearch cluster.

If I had to pick just one feature that has the biggest impact on my daily workflow, it would be the unified AQL. Writing backend services in Python or Go, or debugging anomalies in our logs, AQL simplifies my tasks because I do not have to switch between different query languages. In our old setup, tracing an issue required querying a document store first, pulling IDs into application memory, and firing a second query at a graph or search engine. With unified AQL, I write one single declarative block to filter JSON log payloads by timestamp and match specific error strings, making the process faster and simpler.

The AQL query profiler and explain tools built into ArangoGraph console are important features. When dealing with millions of log events across a sharded cluster, distributed graph traversal can get slow over the network. SmartGraphs allow us to shard our collections by service or tenant ID, keeping related nodes on the same physical machine, which keeps our queries super fast.

If I had to highlight areas where ArangoGraph could improve, I would say the learning curve and tooling for AQL are not ideal. Developers coming from a traditional SQL or document store background may find the optimization of graph traversal and memory usage challenging without proper guidance. Better automated query optimization hints or more guided error messages in the console would definitely make onboarding smoother. Another pain point is cost scaling on the managed cloud tier; running deep graph traversals on heavy data volumes can cause memory consumption to spike quickly, leading to unexpected costs as we scale up.

Having more transparent auto-scaling options or better predictive cost alerts in the managed cloud dashboard would be super helpful, as the graph query memory footprint can spike unpredictably depending on the depth of the traversal. A smarter built-in recommendation for sizing or cost optimization based on query patterns would save teams from trial and error. However, everything else has been running smoothly; I do not see many cons.

I gave it an eight out of ten because it is one of the best database solutions I have used for managing unified log streams and graph relationships without overhead. To elevate it to a solid ten, I would want to see a smoother onboarding experience for AQL with better automated query optimization hints, a more robust and responsive built-in web UI visualizer that can handle thousands of nodes during deep root cause analysis without lag, and more predictable cloud cost scaling or smarter auto-scaling recommendations on the managed tier.

I have been using ArangoGraph for more than three years as a backend database.

ArangoGraph has been extremely stable for our production workloads, managing heavy log ingestion and graph traversal efficiently.

ArangoGraph's scalability has been fantastic for our workload; as our log ingestion volume grows via Kafka, the ability to scale our cluster nodes and use SmartGraphs to shard data locally keeps our distributed queries and multi-hop traversals running smoothly without cross-network bottlenecks. The feature for bulk data import allows us to buffer data sets and import in bulk, which is efficient.

The customer support was good; I would rate it an eight out of ten.

Before ArangoGraph, we used a mix of MongoDB for document storage, Neo4j for graph relationships, and Elasticsearch for full-text search. We switched because maintaining that polyglot setup with dual writes and sync pipelines was a maintenance nightmare; consolidating everything into ArangoGraph eliminated all that glue code and made our architecture much easier to manage.

Pricing and setup were straightforward; using the managed cloud tier on GCP involved quick setup without heavy infrastructure lifting. We have definitely seen a solid return on investment by consolidating our document storage, graph traversal, and full-text search into one unified ArangoGraph cluster.

The experience with pricing, setup cost, and licensing has been good, and the support team of ArangoGraph is very supportive; it has been a great experience overall.

Before choosing ArangoGraph, we evaluated options such as Neo4j combined with MongoDB and Elasticsearch. We opted for ArangoGraph since its native multi-model engine eliminated the complexity of syncing data across multiple separate systems, and it has proven extremely stable for our production workloads, reliably handling heavy log ingestion and graph traversal.

I would rate ArangoGraph an eight out of ten overall, as it is a phenomenal database engine for our use case.

Regarding ArangoGraph's AI capabilities, I think the governance and security they have built are solid. Since we work heavily with ML anomaly detection models, having native support for vector embedding alongside graph relationships and full-text search is powerful for building knowledge graphs and handling context retrieval without needing an external vector database. From a security and governance perspective, the managed cloud tier gives us great peace of mind with features such as enterprise-grade encryption, secure VPC pairing, fine-grained access control, and automated compliance backups.

The accuracy and reliability of ArangoGraph's outputs, especially in AI and vector search aspects, are solid. It combines vector embedding directly with graph traversal and full-text search, ensuring context retrieval for our ML models remains precise. We have not encountered data hallucination or query reliability issues under heavy log ingestion.

We have deployed ArangoGraph on a public cloud as well as on-premises. For our public cloud deployment, we use GCP to deploy ArangoGraph utilizing their fully managed public cloud service.

If I could give advice to anyone considering using ArangoGraph, I would say definitely dive into it if you are tired of managing a messy multi-database stack. The native multi-model design and unified AQL will save tons of architectural headaches. Just plan your indexing and test your graph traversals early to maintain performance as your data scales.

ArangoGraph's best use case is relationship mapping, such as finding connections between entities like which user interacted with which product through which channels. Graph traversal queries make this extremely fast and intuitive.

ArangoGraph changed the way our teams think about data. Instead of thinking in tables and rows, we started thinking in relationships and connections. This mental shift improved our overall data modeling approach across the entire project. The graph traversal features were transformative; finding second and third degree relationships between entities that would have required multiple complex SQL joins was simply solved with a straightforward AQL query in ArangoGraph. This directly improved our application's recommendation logic performance.

ArangoGraph has several concrete positive impacts on our organization. The first and most significant was database consolidation; before ArangoGraph, we were running Neo4j for graph data and MongoDB for document storage separately. Replacing both with one ArangoGraph reduced our infrastructure cost by roughly 40% and eliminated the operational overhead of managing two separate database systems.

The second impact was query performance improvement; our recommendation engine querying that previously took 800 to 900 milliseconds across two databases came down to under 100 milliseconds with ArangoGraph, which is nearly a 90% improvement in our response time. This directly improved our application's user experience.

The third was developer productivity; once the team learned AQL, development speed increased noticeably. Features that required writing separate queries for graph and document data now only needed one AQL query, leading to an estimated 30 to 35% reduction in backend development time for data-related features. Finally, onboarding new team members became faster as they only needed to learn one database system instead of two, significantly saving training time.

Out of all the positive impacts, developer productivity had the biggest effect on our team's day-to-day work. The reason is straightforward; our team was small, so every hour saved in development directly translated to faster feature delivery and better product quality. Before ArangoGraph, a typical data feature required our developers to context switch consistently—writing a Cypher query for Neo4j, then switching to MongoDB query syntax for document data, and finally combining the results in the application code. That back and forth was mentally exhausting and error-prone.

After switching to ArangoGraph, that entire workflow collapsed into a single AQL query. Developers stayed in one mental context, using one query language with one database connection, and the cognitive load reduction was immediately noticeable. A feature that previously took developers two to three days to build and test across two databases now only takes about a day in ArangoGraph, which is a 30 to 35% time savings compounded across every sprint, every feature, and every developer. This also improved code quality; less glue code stitching results from multiple databases means fewer bugs, a cleaner codebase, and easier code reviews. While cost savings and performance were important, developer productivity was the change we felt most tangibly every single day.

ArangoGraph's best features include the multi-model capability, which allows it to handle graphs, documents, and key values all in a single engine, making it a huge differentiator. AQL, or ArangoGraph Query Language, is incredibly powerful; you can traverse graphs, filter documents, and aggregate data all in one query. Once learned, it feels more natural than SQL for relationship-heavy data. The Visual Graph Explorer allows you to see your entire data as a connected graph on screen, invaluable for spotting modeling issues instantly. Smart Graphs intelligently distribute graphs across cluster nodes to minimize network scope during traversals, resulting in dramatically faster query performance at scale.

In my daily work, I definitely rely on AQL, the ArangoGraph Query Language, out of all those features. Everything we did in ArangoGraph ultimately comes down to querying data, whether finding relationships between entities, filtering documents, or arranging results for our analytical pipelines. AQL is something we used every single day. Its flexibility is exceptional; an AQL query could traverse a graph, filter by document properties, and return aggregate results all at once. In a traditional SQL setup, this would have required multiple queries across multiple databases. For example, in my recommendation engine, we wrote an AQL query that started from a user node, traversed product nodes while filtering by ability and score, and returned ranked recommendations—all in one query. The power in a single statement is something I had never experienced before. While the Visual Graph Explorer was a close second in value, especially during development and debugging, AQL was what I lived in daily. That is why we almost always use AQL.

In terms of features, the most underrated aspect I wish more people knew about is Foxx Microservices. Most people who use ArangoGraph focus on the graph and multi-model capabilities, which makes sense, but Foxx surprised me when I discovered it. Foxx allows you to write custom REST APIs and endpoints directly inside the database using JavaScript. Instead of building a separate backend service to expose certain data operations, you can write the logic right inside ArangoGraph and expose it as an API. This was transformative for our project; we had certain complex graph traversal operations that needed to be exposed as endpoints, and instead of building separate Node.js services, we wrote Foxx Microservices directly in the database, significantly reducing our backend complexity and improving performance since the logic runs right where the data lives.

The first and biggest pain point I noticed was the AQL learning curve; for developers coming from an SQL background, AQL feels initially unfamiliar. There are no widely available online courses or bootcamps teaching AQL in the way that there are for SQL or even Cypher. Better structured learning resources and interactive tutorials would significantly lower the barrier to entry. The second pain point is pricing transparency; cost estimations at scale are not straightforward. When planning for infrastructure growth, it is difficult to predict exactly how costs will scale with increasing nodes, edges, and query volume. A proper cost calculator on their website would be extremely helpful. The third pain point is query optimizer limitations; for very complex multi-level graph traversals, the query optimizer sometimes makes suboptimal execution choices, requiring us to manually hint the optimizer in certain cases, which should not be necessary in a mature database platform. Finally, the ecosystem maturity is another concern; compared to MongoDB or PostgreSQL, the community and third-party tooling around ArangoGraph are still relatively small, resulting in fewer Stack Overflow answers, fewer integrations, and fewer tutorials. None of these are deal-breakers, but they reflect the growing pains of a platform that is still maturing. The core technology itself is generally excellent.

One thing I really wish ArangoGraph would improve is the Visual Graph Explorer performance. It is a fantastic feature conceptually, but when the graph grows beyond a certain size, say fifty thousand plus nodes, the explorer becomes noticeably sluggish. Rendering a large graph in the browser gets heavy, so a smarter sampling or progressive loading approach would make it much more usable at scale. Another small but frustrating issue is the error messaging in AQL; when a query fails, the error messages can sometimes be cryptic and unhelpful. As a developer, you often spend more time debugging the error messages than actually fixing the query. More descriptive and actionable error messages would save a lot of developer frustration. Lastly, I would also appreciate a dark mode option for the UI; it sounds minor, but developers spend long hours in the interface, and a dark mode option is something the community has been requesting for a long time. These are not critical issues, but they are the type of polish that separates a good product from a truly great one.

A few more improvements I have not mentioned include better GraphQL support, as ArangoGraph has some GraphQL integration, but it is not seamless. Many modern applications are built on GraphQL, and having first-class GraphQL support would make ArangoGraph much more accessible to frontend developers who are not familiar with AQL. Improved data import tools are also needed; migrating existing data into ArangoGraph from other databases like PostgreSQL or MongoDB has been more manual than expected. A proper migration wizard with schema mapping and data transformation built in would significantly reduce onboarding friction. Lastly, better Kubernetes integration would benefit teams running hybrid or on-premises deployments, with native Kubernetes operators being more mature and better documented, as we have seen several community complaints regarding this during our research phase. These improvements would really elevate ArangoGraph from a great database to a complete graph intelligence ecosystem.

I have been using ArangoGraph for about one year, primarily for a data pipelines project where we need a graph-based relationships mapping between entities.

My practical advice for anyone considering ArangoGraph is to think in graphs before starting. Before writing a single line of code or creating any collections, sit down with your team and map out your entities and relationships on a whiteboard. ArangoGraph rewards good upfront data modeling; a poorly designed schema is very hard to fix later. Secondly, invest seriously in learning AQL early; do not underestimate this. AQL is the key that unlocks everything ArangoGraph can do, so spending the first week learning AQL syntax and patterns before diving into anything else will pay dividends throughout the entire project. Start with an ArangoGraph free trial; do not commit to a paid plan until you have run real queries against your actual data. The trial is generous enough to validate your use case properly. Also, use the Visual Graph Explorer during development; it sounds like a nice-to-have but is actually extremely valuable for catching data modeling mistakes early, before they become expensive product problems. Join the ArangoGraph community forum as the official documentation has gaps, especially for advanced features; the community fills those gaps remarkably well. Lastly, do not use ArangoGraph for everything; it excels at relationship-heavy data, while a traditional relational database is still better for purely transactional workloads. Use the right tools for the right job.

A few final thoughts I would share are that ArangoGraph is genuinely one of the most underappreciated databases in the market today. The multi-model approach, the power of AQL, and the unique features like Foxx Microservices put it in a league of its own. However, because it is not backed by a hyperscaler like AWS or Google, it does not get the attention it deserves. The timing for ArangoGraph could not be better with knowledge graphs becoming increasingly important for AI applications like RAG pipelines and LLM grounding. ArangoGraph is perfectly positioned to become a critical piece of modern AI infrastructure. For Indian developers and startups, especially, ArangoGraph with AWS Mumbai region deployment is an excellent combination of low latency, reasonable pricing at startup scale, and zero infrastructure overhead, making it very attractive for lean teams. I hope this review helps other technology buyers make informed decisions; ArangoGraph has real strengths and real areas for improvement, and I have aimed to represent both honestly throughout this interview. My overall rating for ArangoGraph is eight out of ten.

My main use case for ArangoGraph is to build a bridge between us and the client to showcase applications such as social networks, recommendation engines, fraud detection, network and dependency analysis, knowledge graphs, and graph RAG applications, as well as supply chain and logistics tasks. I use the enterprise edition, which provides community and open-source options.

Out of all those use cases, the RAG solution is the project that stands out to me as especially interesting and challenging, as it provides the highest impact. This is currently one of the hottest use cases. Imagine an enterprise chatbot that, instead of storing documents in isolated chunks, works with AI to understand who owns a service, which projects depend on it, who the manager is, and what incidents have occurred recently. These things can be easily tracked from ArangoGraph tools. Instead of storing documents separately, we create a knowledge graph that maps employees to projects, applications to services they depend on, and everything else properly. This delivers significant impact on enterprise-grade AI assistants and graphical RAG orchestration and architecture.

Those improvements show up for my team and client in that managers are able to track who is doing what easily within a group. Additionally, during discovery sessions with clients, we previously spent considerable time understanding requirements and providing feedback before scheduling follow-up sessions. Instead, we can now collect everything instantly in an organized place and speak back to the client immediately.

ArangoGraph has positively impacted my organization by enabling discovery sessions that we can close within two weeks instead of keeping them open for a month, reducing delays by nearly 50 percent. This has also led to cost savings for my team and client because we can get statements of work signed instantly and start work without delay.

The best features ArangoGraph offers are the graphical database, document database, key-value database, and search capabilities, all unified under a single query language like AQL on one platform.

Out of those features, the one my team uses most is the key-value database, which helps us map all discovery events in a schedule or proper manner more effectively.

The features that stand out to me about ArangoGraph include identity and governance, zero-trust analysis, threat hunting, and privilege escalation detection. These can be easily graphed over our database, allowing us to track them efficiently. Although these may seem small, they help non-technical staff carefully review the information.

ArangoGraph can be improved in terms of pricing, as enterprise pricing is quite hefty.

I would also note that the AI feature in the UI can be improved. I find the accuracy and reliability of ArangoGraph's output to not be exactly as expected, though some issues can be managed.

I have been using ArangoGraph for beyond three years.

ArangoGraph's scalability is highly rated by us. Day by day, our workloads continue to increase, and ArangoGraph still displays the graph without any redundancy.

Customer support for ArangoGraph is great, and their response is quite quick.

Before ArangoGraph, we used Neo4j. We switched from Neo4j to ArangoGraph because companies typically choose ArangoGraph over Neo4j when they want more than just a graph database. ArangoGraph offers multi-model capabilities versus pure graph functionality, combining two to three types of data to prepare a graph accordingly. ArangoGraph supports graph data, documents, JSON files, key-value data, search capabilities, and value-based AI workloads. This multi-model approach is why enterprises choose ArangoGraph.

If others are looking into using ArangoGraph, my advice is that if they want to input different data and group it to see statistics, they can confidently choose ArangoGraph. I would rate this product a 7 out of 10.

My main use case for ArangoGraph is that our data is so messy, so we need a graph database to predict and retrieve the data. There is also a product called graph machine learning models that we utilize.

A specific example of how I use ArangoGraph with our messy data is that in our company, some employees are taking sick leave or casual leaves on Saturday or Monday without any apparent purpose. With ArangoGraph, I used it to visualize who is exactly taking sick leave and casual leave in a graph format and issue a small warning about that.

Regarding my main use case with ArangoGraph, I can add that we also used it regarding cyber attacks, and there are many more ways I utilize it.

ArangoGraph has positively impacted my organization by cutting down our costs and mostly increasing efficiency, which means we do not have to do the work manually.

I can share specific outcomes where mostly it is about a 20 to 30% reduction in costs, and the time saved is around 80%.

The best features ArangoGraph offers include ArangoSearch engine which has inbuilt embeddings to store and can process the graph after we dump a lot of data into it. Additionally, there is a product called AI Contextual Data Layer which can retrieve information using natural language.

Out of those, the feature I find myself using the most is the Equalizer, which allows me to simply ask in natural language, and it internally converts that into AQL and executes it in the database, giving me the answer in natural language. This makes it very useful to me.

Regarding the features, I would add that there are features called Importer and Retriever which are available in the public document. The Importer allows us to import data that automatically converts it into a knowledge graph, while the Retriever retrieves relevant information based on whichever query is asked.

I think ArangoGraph can be improved as there are many bugs, but the development team is trying to fix them.

I would add that we used to bring our own key as ArangoGraph did not provide any specific fine-tuned LLM for our use case. We need to use our own API keys, such as OpenAI or Claude, but we need our data to remain safe. I think it is better to move from GPUs and develop their own LLM.

Regarding ArangoGraph's AI capabilities, at the time I used it, I did not think they provided much security.

Regarding ArangoGraph's AI capabilities, its accuracy and reliability of output sometimes depend on user queries. The main thing it is missing is AI guardrails and security. When I used it, we could easily inject the prompt and it would break, but I do not know about it now as I have not used it in a while.

I have been using ArangoGraph for about one year and two months.

I do not think ArangoGraph is stable as they release updates every month with many bugs. Although it might become stable at some point, right now I do not think so.

ArangoGraph's scalability is pretty good and it depends on the environment, mainly involving DevOps and Kubernetes.

I would rate customer support as mostly 9 out of 10, but when it comes to AI capabilities, it was like 4 out of 10, though overall it was good.

I would rate the customer support a seven.

I previously used Neo4j, which offers the same capabilities but has a better solution for our use case.

I have seen a return on investment as previously we cleaned up the data with six to seven members without ArangoGraph. Now it is a one-person job, while the money kind of increased, but is expected to decrease over time, with the time saved being huge.

The experience with pricing, setup cost, and licensing was reasonable, as the setup cost was not that expensive.

Before choosing ArangoGraph, we did not evaluate any other options, but after choosing it, we made a shift to Neo4j.

On a scale of 1 to 10, I would rate ArangoGraph a seven.

I chose seven because when I tried to use another product related to it, the UI is not that great compared to Neo4j.

ArangoGraph is deployed in my organization in an air-gapped environment.

The advice I would give to others looking into using ArangoGraph is that they first need to understand the graph fundamentals and then learn basic SQL, specifically AQL, and start with a smaller dataset, trying out the Enterprise Edition in Docker before contacting the Arango team. If they need AI capabilities, they must shift to the AI Contextual platform and have a basic understanding of Python to integrate with the code, along with having APIs for using ArangoGraph for AI purposes.

My main use case for ArangoGraph is to display graphs on the UI so users get a view with a graph-based interface showing relationships such as who is a customer, who is a buyer, and who is a supplier. I maintain these relationships using ArangoGraph.

I can provide a specific example of how I use ArangoGraph to maintain buyer-supplier relationships. In Arango, which is a multi-model database, I use ArangoGraph with edges and vertices. My vertices are customers and suppliers, and other vertices are items that the supplier provides to the buyer. The relationships between products, customer products, and suppliers are maintained through edges, while vertices contain customer, product, and supplier information. This is how I use ArangoGraph to show the relationship between the customer, seller, and buyer of products.

This is my main use case because without a graph, users need to check tabular information and read everything to understand relationships. With a graph using edges and vertices, users can easily identify connections. For example, if a buyer purchased three products—product A, product B, and product C—from a specific supplier, users can easily see the delivery status and what products were bought through these graphs.

ArangoGraph has had a positive impact on my project, mainly in managing visualization of complex relationships between buyers, suppliers, and products. Previously, understanding how different entities were connected could be challenging. With ArangoGraph, I can represent relationships using vertices and edges and retrieve connected information through graph queries. This makes it easier for the backend to provide relationship data to the front end when users can explore connections visually. It also provides flexibility when adding new entities or relationships as business requirements evolve. Overall, the biggest benefits are better relationship management, easier data exploration, and more flexibility in the application.

I have seen positive improvements, especially in how I can retrieve and explore relationships. For example, when a user wants to see a supplier connected to a particular product or buyer, I can use graph traversal queries to retrieve those relationships directly. This has made relationship-based data retrieval more straightforward for backend development and has helped provide a better graph experience on the UI. In terms of exact metrics, I have not formally benchmarked the time-saving or performance improvement, but from my development perspective, the main benefits have been simpler relationship queries and easier maintenance with greater flexibility as the data model evolves.

One of the best features of Arango is that it is a multi-model database, and specifically, the best features of ArangoGraph are scalability and user interface, which are most important in the e-commerce domain. Previously, I was in the healthcare e-commerce domain, where scalability matters more, and that is the feature it provides, which is very useful for my work. As I mentioned, the user interface definitely adds more value whenever users see details using edges and vertices.

The scalability of ArangoGraph is useful for my project because I manage relationships between customers, buyers, suppliers, and products, and this data keeps growing over time. As more suppliers, buyers, and products are added, the number of relationships also increases. ArangoGraph provides options to scale as data grows, which helps me plan for increasing data volumes and more complex graph queries. From the backend perspective, this is valuable because I want users to explore these relationships smoothly without major changes to the application architecture. Overall, scalability helps me support growth and manage increasingly complex relationships.

Another useful feature is AQL, which allows me to retrieve data through graph traversal queries. The flexibility of graph traversal capability and ease of managing complex relationships are the features I appreciate most.

Overall, ArangoGraph has been useful for my project, but I think there are a few areas where it could be improved. One area is the developer experience, especially when working on complex graph queries. Better debugging tools and more detailed query performance insights would make troubleshooting easier. Another area is graph visualization, where having more advanced built-in visualization and exploration features would be helpful, especially when dealing with a large number of vertices and edges.

When working with complex relationships involving multiple buyers, suppliers, and products, it would be helpful to have more intuitive tools to analyze graph traversal queries and identify performance bottlenecks. Additionally, better integration examples for backend applications would make development and troubleshooting easier.

I have been using ArangoGraph for two years.

ArangoGraph has been quite stable for my use cases. I have been using it for around two years to manage the relationships between buyers, suppliers, and products. From a backend developer perspective, it has been reliable for storing and retrieving graph data using AQL queries, and I have not encountered any major stability issues in my day-to-day development work.

ArangoGraph offers good scalability for my use cases. In my project, I manage relationships between buyers, suppliers, and products, and as the number of entities increases, the relationships also become more complex. ArangoGraph supports horizontal scaling, which is useful for handling growing data volumes and increasing workloads. From a backend development perspective, its graph traversal capability helps me manage these relationships efficiently, and overall, I am satisfied with its scalability, although I have not personally conducted large-scale performance or load testing.

Customer support for ArangoGraph is good. I would rate the customer support a nine out of ten.

Based on my experience, I would rate ArangoGraph an eight out of ten.

I chose an eight out of ten for ArangoGraph because it has been really useful for my project, especially in managing complex relationships between buyers, suppliers, and products. I appreciate the graph traversal capability, flexible data modeling, and AQL query language. There is still some room for improvement in areas such as query debugging, performance monitoring, and developer documentation, but overall, I am satisfied with the product and its capabilities.

Regarding ArangoGraph's AI capabilities, I think its governance and security are useful, particularly around access control and managing permissions. Since my application deals with business relationships between buyers, suppliers, and customers, data security and controlling access to sensitive information is important. Features such as fine-grained access control, audit logging, and better visibility into how data is accessed by AI applications are important. Overall, my experience with ArangoGraph has been positive, but I would need more hands-on experience with the AI governance features to evaluate them properly.

Regarding ArangoGraph's AI capabilities, while I have not explored them extensively because my primary use case is managing the graph-based relationship between buyers, suppliers, and products, my experience with the accuracy and reliability of the graph query results has been positive. ArangoGraph helps me retrieve connected data using AQL and graph traversal, which is important for managing accurate business relationships.

I would recommend ArangoGraph to organizations that need to manage complex relationships between different entities. My advice would be to first understand your use case and design your graph accordingly.

A specific example of how I used ArangoGraph for supply chain visibility involved having information about buyers and suppliers throughout the world, creating supply chain visibility to connect these dots, which I accomplished using ArangoGraph.

This involved the import and export of custom data throughout the world.

If I had to use other providers for the same tasks, the general cost would be higher, and since ArangoGraph operates somewhat like SQL, it allows me to use my current pipeline as it is, which has been helpful in speeding up the process.

When it comes to valuable graph-based analytics, I found tools for pointing out concentrated risk, identifying bridges in the network, performing risk analysis, and achieving tier visibility to be particularly useful.

In terms of accuracy and reliability of output related to ArangoGraph's AI capabilities, I find it reliable, but it lacks domain-specific knowledge and insider guardrails from the company using ArangoGraph, which is something that should be added on the company's side.

Regarding ArangoGraph's AI capabilities, I don't feel I have any issues with its governance and security.

ArangoGraph is deployed in my organization currently using public cloud.

I use GCP as my cloud provider.

My advice for those looking into using ArangoGraph is that it depends on their use case and finances. First, I recommend exploring other providers and finding the best fit, which depends on factors like workload, pricing, scalability, and security.

My main use case for ArangoGraph is to run queries to find data while we're developing.

A specific example of how I use ArangoGraph for those queries during development is debugging and making sure everything is working. In my previous role, I worked on a shipping app that functioned as a track and trace for parcels, and I used clients to check the database against the client and the packages to ensure everything was functioning.

ArangoGraph has positively impacted my organization because it is a good piece of software that developers can learn quickly.

Specific positive outcomes since using ArangoGraph include its speed. Arango has always been quick, and the query language is quick and easy, allowing us to get things pushed out the door quicker.

I estimate that we save at least a couple of days a month.

The best features ArangoGraph offers are its simplicity, being built on JSON, which makes it very quick to see an overhead of certain bits of data, and its query language being similar to MySQL, with a slight learning curve but nothing too massive.

Being able to quickly see an overhead of certain bits of data helps me in my day-to-day work by allowing for debugging and making sure everything works before we ship. We can run queries, and from a high overhead view, we know whether it is working or not by the data that is returned.

Along the line, we will be sharding our database.

I think the open-source version is good, but when moving on to a paid version, there are a few things that could be taken from the paid version into the open-source version.

I have used Arango for seven years, and I have only been using ArangoGraph for about a year.

I think ArangoGraph is stable; we have never had any problems.

The scalability of ArangoGraph is good, and it is much easier to scale when the documents are just JSON.

Before using ArangoGraph, we were on Rails with a Postgres database, and we decided to switch because we needed something a little bit faster.

My experience with pricing, setup cost, and licensing was okay; we just had to do a bit of pre-planning.

Before choosing ArangoGraph, I evaluated staying with Postgres as one of the options.

On a scale of 1 to 10, I rate ArangoGraph an eight.

I give it an eight because I am really happy with how it works and how it performs, but I am missing the two points because the enterprise version is a bit too expensive for new startups.

Regarding ArangoGraph's AI capabilities, I trust its governance and security, having no reason to question it or be worried about it.

In terms of ArangoGraph's AI capabilities, the accuracy and reliability of output seem to be fine; it seems to be quick and good.

At the moment, we are using Vultr as our cloud provider.

My advice to others reading reviews on PeerSpot who are looking into using ArangoGraph is to learn the query language. It is really not that hard, and by learning the query language, you will get the most out of ArangoGraph.

The main use case of ArangoGraph is data analytics, and I have conducted multiple kinds of POCs where I experimented on fraud detection where I identified suspicious connections or spurious activity between account transactions and users. I also dabbled in social media analysis, for example, I wanted to conduct experiments on finding mutual friends in a particular social media platform.

In case of fraud detection, I have used ArangoGraph for finding unwanted or illegal transactional details in banking activity or card activity. Whenever a particular user makes an online transaction using a credit or debit card, that is where ArangoGraph comes into the picture. Since ArangoGraph is a graph database, it exposes hidden relationships between the customer, transactions, IT devices, and merchants.

Apart from fraud detection, I have also used ArangoGraph in data engineering. From my data engineering background, ArangoGraph can be used for master data management, data lineage tracking, and finding relationships between enterprise data sets.

ArangoGraph has been very helpful in my organization as we extensively use it for multiple use cases such as detecting financial fraud, data engineering use cases in master data management or data lineage, and social media analysis.

Picking one specific example, using ArangoGraph has benefited us to have a single customer view in case of financial fraud detection. It helps us for profiling risk and fraud detection. When I go deeper into fraud detection, it helps us identify shared devices and shared IP addresses, and it helps us in anti-money laundering as well.

The best features ArangoGraph offers include support for graph traversal and relationships between queries very efficiently. On top of it, it also has its own query engine known as AQL, so using this, I can query graphs and documents. It also scales or expands horizontally through clusters, and one important feature which I appreciate is that it is very suitable for real-time analytics on connected data.

AQL is basically used for querying graphs and documents, so it is similar to SQL. AQL is something I can use to interact with ArangoGraph, so it can query documents, edges, and graphs using a single language. Not only relational but also non-relational databases such as MongoDB and other graph-based databases can use AQL.

AQL can be used for traversal both inbound and outbound, for multi-hop relationship analysis, finding the shortest path between graphs, and is widely used for anti-money laundering detection patterns and financial frauds.

The governance and security is quite good. Compared to what I have seen for other graph-based databases, ArangoGraph has a comparatively better advantage in terms of data security, and that is why it is the preferred choice in my organization.

ArangoGraph can be improved by adding more AI capabilities as everything is moving into the AI space nowadays. If AI capabilities such as agentic AI or Generative AI can be added, it can definitely have more advantage compared to its traditional peers.

In terms of data quality, some implementations use ArangoGraph, so data quality checks would be beneficial. If ArangoGraph could have out-of-the-box features such as identification of duplicates, missing edge validation, or entity resolution already added in-built, it will have more added advantage.

The features I mentioned for improvement are already in the pipeline and should be expected in the next quarter, but apart from that, the working experience I have had with ArangoGraph has been quite fruitful and I expect the same to continue with all the incoming new features that are expected to arrive by next year.

I have been using ArangoGraph for close to five years now.

ArangoGraph has experienced stability issues.

Scalability-wise, ArangoGraph is quite scalable in terms of horizontal scaling. Whenever there are peak times, ArangoGraph is definitely scalable, and scalability is one of its key strengths.

Adding more servers and nodes to a cluster provides vertical scaling based on the workload, and it provides high availability and distributed data storage, so all these features are an advantage compared to other options.

Customer support has been quite good. Whenever there are challenges, I reach out to ArangoGraph customer service, open up a ticket with them, or simply send an email, and I get support from them immediately.

I would rate customer support nine out of ten.

I used traditional databases, NoSQL and SQL databases such as MongoDB, Oracle, MySQL, and PostgreSQL. Using those for my use cases for fraud detection, social media analysis, and master data management compared to using ArangoGraph gave us a more competitive advantage. The processing and solutions provided by ArangoGraph supersede whatever the solution provided by the previous platforms.

I cannot give exact numbers in terms of money saved or time saved, but ArangoGraph has been quite beneficial compared to traditional graph databases.

So far, everything is going well, and there are no major concerns in terms of ArangoGraph licensing and pricing cost. When I was actually trying to learn ArangoGraph, I used the community edition, which is the free version. Once I gained substantial experience with that, I went with the enterprise edition within the company when I had use cases within the company itself.

When I started working with ArangoGraph with the community edition, the features it had when I was exploring were liked by everyone, and I went with that, so I did not evaluate other options when choosing ArangoGraph.

On a scale of one to ten, I would rate ArangoGraph nine, simply because the features that I have explored are not only at par but exceed compared to its competitors. The only basic area I would say is in terms of GenAI and knowledge integration, as most vendors and competitors are integrating Generative AI and machine learning capabilities within themselves.

In terms of accuracy and reliability, ArangoGraph is reliable, but it certainly requires human review. Obviously, it is important that core AI principles are incorporated such as fairness, transparency, and responsible AI. So far, whatever I have observed or checked in terms of ArangoGraph, it is quite useful.

In my organization, ArangoGraph is deployed on a hybrid cloud. Some deployment is on a private cloud where security and customer data are of utmost importance. However, if it is not dealing with customer-specific data, it is deployed on the public cloud, and I use AWS for the public cloud deployment.

I would recommend others if they have use cases in social media analysis, data analytics, data engineering, master data management, data lineage, or financial fraud such as anti-money laundering or illegal banking transactions. They can definitely give ArangoGraph a try and explore its features, which are definitely above its competitors.

ArangoGraph's main use case is to save interconnected data and traverse across connected data similar to how you traverse through a graph. In a traditional database, you need foreign key connections, but ArangoGraph enabled me to traverse through efficiently with minimal complexity.

In one of my projects, I had to connect certain privacy records entities to certain master data, and this master data needed to be connected to another set of master data. I had to find dependencies between master data and determine what master data privacy records were connected to. When this happened with thousands and lakhs of records, ArangoGraph really helped in that case.

I was able to easily perform queries, and the complexity and time consumption were very small compared to using a traditional database. For some queries that took one minute with traditional databases, I was able to complete them within four seconds in ArangoGraph when testing with certain cases. This was the main impact.

The best feature of ArangoGraph was that I could decide the mode of traversal. The querying was smooth, and I could configure the understanding of how to query and the level of depth I needed to traverse through the data.

ArangoGraph provided AQL, which is Arango Query Language, as the go-to way for queries, and that was really easy to understand and digest. Within a very short time, I was able to figure out how to do this querying and understand how the language works. The documentation was easy to understand and apply to my use cases.

It could be more performant if possible, and greater speed could be achieved. Other than that, I do not have many suggestions.

I used ArangoGraph for three years in my career at the initial stage.

It is stable.

Scalability was good.

Customer service was good, and I would rate it at nine.

I did not use any other solution previously.

The setup cost was satisfactory.

The only other solution I considered was Neo4j.

I would rate ArangoGraph at eight. It was really good and does the job. I never faced any failure scenario or deadlock situation, and the support team was always helpful. These are the reasons for my rating. Overall, I would say the experience was good. I would recommend comparing it with Neo4j for your use case.

My main use case for ArangoGraph is to build a customer graph in order to create a relation between customer and end users. I connect all the user related data together between the orders that they made from the supplier and customers.

The user interface is the best feature that ArangoGraph offers. The simplicity of the user interface is very appealing to me. ArangoGraph has positively impacted my organization as we made a 30% saving in order to build this graph. The savings were achieved mostly through time cost.

I think that ArangoGraph can be improved.

I have been using ArangoGraph for six months.

I advise others looking into using ArangoGraph to speed up the development using all the features that the product provides. I gave this review a rating of 8.