TrustRadius
Limited SaaS solution that integrates seamlessly into Amazon ecosystem
https://www.trustradius.com/nosql-databasesAmazon DynamoDBUnspecified8.591101
Anudeep Palanki profile photo
Updated July 24, 2017

Limited SaaS solution that integrates seamlessly into Amazon ecosystem

Score 8 out of 101
Vetted Review
Verified User
Review Source

Overall Satisfaction with Amazon DynamoDB

We made a transition to using DevOps at our organization and AWS is our choice of cloud provider. For a new micro service we built, we need a NoSQL database, that provides basic querying capability and requires minimum maintenance. Considering that Amazon offers DynamoDB as software as a service, it is a de-facto choice for us. It is being used across departments for various micro services. Understanding the querying capability is critical in selecting a database and DynamoDB fits into a use case where we need to query the nested array within the first layer of JSON objects.
  • Security and managing infrastructure are the first reason why we selected DynamoDB. It takes quite an effort to set other NoSQL databases up in EC2 instances. Since DynamoDB offers single click table (Collection equivalent in MongoDB) setup, it's pragmatic to give this a first shot.
  • It provides decent querying capabilities with excellent documentation. If you have a JSON structure that's relatively flat (not more than 2 nested JSON objects) that needs querying, DynamoDB would be a great choice for you.
  • Neat CLI API that allows for easy setup in a local development environment would make the life of a developer a breeze. This again brings the benefit of having great documentation.
  • Better querying capability, we had a requirement where we wanted to index and query nested arrays. For example: our sample data structure: {a: [{b: ['array of interest' ]}]}. DynamoDB does not provide neat way to query the 'array of interest'. Hence we had to shift few of our Databases from DynamoDB to Postgres.
  • DynamoDB does not offer any sort of database functions or triggers that would help manipulate the data before performing a transaction. This is key for part of our NoSQL datastore. For example: we wanted to manually maintain consistency of order variable in a JSON array i.e. if we add an element to middle of the array, the order of rest of the elements should shuffle within a single transaction. This functionality leaves something to be desired from DynamoDB.
  • Transaction management is something that DynamoDB does not offer. For example: if we want to perform a read and write within a same transaction, DynamoDB does not offer this capability. Hence, DynamoDB is not a great fit for highly concurrent environment.
There are some feature that DynamoDB does a little differently compared to other products in the market.

Effective:
  • Security policy using Amazon IAM. The security on the database is controlled by broader Amazon IAM policy. This negates the need to manage individual security policies for the database.
  • This also integrates very well with rest of the Amazon eco system. Deploying your applications in Amazon VPN would allow rest of the applications to communicate between each other without compromising on security.
Ineffective:
  • Not an open source technology: the drawback with not being an open source tech is its development is dependent on the number of resources that Amazon dedicates to the software. The documentation while great in some areas, lags when you want to get work done using some specific functionality of the API.
  • Since the Amazon manages the instance, the amount of time a developer needs to spend configuring the database is less. For comparison, if we were to manage the same instance manually, we need to set up EC2 instance, install the DB, setup backup scripts, track backup failures, which is a great overhead for the dev. Using DynamoDB this overhead is reduced and hence having a great ROI.
  • Great documentation and easy setup makes an easy learning curve to transition to DynamoDB. Only caveat is as with any database, the data structure should be thoroughly analyzed for types of querying because there are limitations with the DynamoDB API.
  • Ties very well with rest of the Amazon eco system. Having rest of the applications in Amazon allows managing the application security a breeze.
Main advantage of DynamoDB is Amazon's offering as SaaS. This removes the need for managing the database. DynamoDB is well suited for querying simple and flat JSON objects.

Compared to PostgresSQL, I would pick Postgres over Dynamo considering that Postgres is very mature and has robust support for SQL and NoSQL data. Best part about Postgres is its offered in Amazon RDS, which makes setting up a new instances as easy as a DynamoDB. Postgres is also an open source tool and has proven legacy in support.

MongoDB offers great support for querying nested data structures and blob data. MongoDB also has a mature querying language. Only caveat with Mongo is it requires manual setup on an EC2 instance that causes developer overhead in setting up and managing the instance.
PostgreSQL, Amazon Relational Database Service, Amazon S3 (Simple Storage Service), Amazon Elastic Compute Cloud (EC2), CloudFoundry, Jenkins, CircleCI, Travis CI, GitHub, IntelliJ IDEA, IntelliJ WebStorm
We started with DynamoDB for few of the applications that I built as its a pragmatic solution. But as our data started to evolve, we started to hit limitations of the DynamoDB's querying and it gets increasingly frustrating to write code around the DynamoDB's limitations that I mentioned earlier. This caused us to switch from DynamoDB to Postgres in both the cases where we mixed the traditional SQL with NoSQL data.
Amazon's DynamoDB is very well suited for:
  • Applications with a relatively flat data structure.
  • Relatively simple querying on data.
  • Scenarios where the developers do not have time to manage the database.
Less appropriate if the data:
  • Structure is complex and has object depth beyond 2 layers.
  • Requires indexing and querying on nested arrays.
  • Requires executing multiple queries within a single transaction.