DEV Community: Nivetha Gopalakrishnan

Nivi Meets Neptune: Exploring Amazon Neptune☁️

Nivetha Gopalakrishnan — Tue, 15 Sep 2026 16:50:40 +0000

Introduction

When I started exploring AWS database services, I learned that not every application stores data in simple tables and rows. Some applications need to understand the relationships between data. This is where graph databases become useful.

For my AWS learning journey, I explored Amazon Neptune, a fully managed graph database service provided by AWS.

In this blog, I will explain what Amazon Neptune is, why it was created, how it works, its important features, and how it can be used in a college or student project.

What Is Amazon Neptune?

Amazon Neptune is a fully managed graph database service from Amazon Web Services (AWS).

Unlike traditional relational databases that organize information mainly into tables, Neptune is designed to store and analyze relationships between data.

A graph database represents information using concepts such as:

Nodes – represent entities
Edges – represent relationships between entities
Properties – describe nodes and relationships

For example, in a college application:

Student ──ENROLLED_IN──> Course
Student ──FRIENDS_WITH──> Student
Course ──TAUGHT_BY──> Professor

This type of relationship-based data can become complicated in traditional databases. A graph database makes these connections easier to represent and query.

Why Was Amazon Neptune Created?

Many modern applications depend heavily on relationships.

Examples include:

Social networking applications
Recommendation systems
Knowledge graphs
Fraud detection
Identity and access management
Network and IT operations
Recommendation engines

In a relational database, finding connections across many tables may require multiple joins. Graph databases are designed specifically for these connected-data scenarios.

Amazon Neptune was created to provide a managed AWS service for graph workloads, so developers can focus on building applications instead of managing database infrastructure.

How Does Amazon Neptune Work?

The basic idea of Neptune is simple.

Instead of thinking only in terms of tables and rows, we think in terms of entities and relationships.

For example:

        ENROLLED_IN
Student ─────────────> Course
   |
   |
FRIENDS_WITH
   |
   v
Student

A simple Neptune architecture can be represented as:

                 User / Application
                         |
                         v
                  Application Layer
                         |
                         v
                  Amazon Neptune
                         |
              +----------+----------+
              |                     |
              v                     v
           Nodes                 Relationships
        Student, Course       ENROLLED_IN, FRIENDS_WITH

An application sends graph queries to Neptune. Neptune processes the query and returns the related information.

Key Features of Amazon Neptune

1. Graph Database

The primary feature of Neptune is its ability to work with graph data.

It is useful when relationships are as important as the data itself.

For example:

Student → Enrolled In → Course
Course → Taught By → Professor
Student → Member Of → Club

This makes Neptune suitable for applications where connected information needs to be queried efficiently.

2. Support for Graph Models

Neptune supports popular graph models and query approaches, including property graphs and RDF graphs.

Applications can use technologies such as openCypher and SPARQL, depending on the graph model and workload.

This gives developers flexibility when designing graph-based applications.

3. Fully Managed AWS Service

Neptune is a managed AWS database service.

AWS handles many infrastructure responsibilities such as database infrastructure management, maintenance, backups, and availability-related capabilities.

This allows developers to spend more time working on the application rather than managing database servers.

4. High Availability and Scalability

Neptune is designed for applications that require reliable database infrastructure.

It provides capabilities for high availability and supports scaling approaches appropriate for graph workloads.

This can be useful when a student project grows from a small prototype into a larger application.

5. AWS Integration

Because Neptune is an AWS service, it can work with other AWS services and applications.

For example, a project could combine:

Amazon EC2
    |
    v
Application
    |
    v
Amazon Neptune
    |
    v
Graph Data

Other AWS services can also be used alongside Neptune depending on the application's requirements.

College / Student Use Case

One interesting college use case is a Student Course Recommendation System.

Imagine a system that stores information about:

Students
Courses
Professors
Departments
Skills
Projects
Clubs

The relationships could look like this:

Student
   |
   | ENROLLED_IN
   v
Course
   |
   | RELATED_TO
   v
Skill
   |
   | USED_IN
   v
Project

Suppose a student has completed Python and Machine Learning courses.

The system could analyze the student's existing course and skill relationships and recommend related courses or projects.

A graph database is useful here because the recommendation depends on the connections between different entities.

Simple Practical Example

Let's consider a basic graph containing a student and a course.

(Nivi) ──[:ENROLLED_IN]──> (AWS Cloud Computing)

In a property graph, we could represent:

Student:
Name = Nivi

Course:
Name = AWS Cloud Computing

The relationship is:

Nivi - ENROLLED_IN -> AWS Cloud Computing

A conceptual openCypher query could look like:

MATCH (s:Student)-[:ENROLLED_IN]->(c:Course)
WHERE s.name = 'Nivi'
RETURN c.name;

The query searches for courses connected to the student through the ENROLLED_IN relationship.

The result could be:

AWS Cloud Computing

This simple example demonstrates why graph databases are useful: the query focuses on the relationship between entities.

Advantages of Amazon Neptune

Relationship-Based Data

Neptune is designed specifically for highly connected data, making it useful for graph-oriented applications.

Managed Infrastructure

AWS manages much of the underlying database infrastructure, reducing administrative work.

Flexible Graph Queries

Support for graph query technologies allows developers to work with different graph data models.

AWS Ecosystem

Neptune can be incorporated into larger AWS-based applications and architectures.

Suitable for Complex Relationships

Applications involving recommendations, networks, fraud analysis, and knowledge graphs can benefit from graph database technology.

Limitations and Things to Consider

Cost

Amazon Neptune is a managed cloud database service, so it can cost more than simply running a small local database.

Before using Neptune in a real project, it is important to understand the current AWS pricing model and estimate the expected usage.

For student experiments, always check the AWS pricing information and monitor resources to avoid unexpected charges.

Complexity

Graph databases use concepts that are different from traditional relational databases.

Students familiar only with SQL databases may need some time to understand nodes, edges, graph models, and graph query languages.

Scalability Planning

Neptune provides scalability capabilities, but applications still need appropriate architecture and capacity planning.

A production system should be designed based on expected traffic, query patterns, and data size.

Security

Security should always be considered when working with cloud databases.

Applications should use appropriate AWS identity and access controls, network security, encryption, and database security practices.

Sensitive student information should never be exposed publicly.

When Would I Choose Amazon Neptune?

I would consider Amazon Neptune when the main requirement of an application is understanding relationships between data.

For example:

Social Network
       |
Recommendation System
       |
Fraud Detection
       |
Knowledge Graph
       |
Network Management
       |
       v
 Amazon Neptune

If an application mainly requires simple tabular data and traditional SQL queries, another AWS database service may be more appropriate.

The important lesson is to select a database based on the application's data model and requirements.

What I Learned

While learning about Amazon Neptune, I understood that databases are not limited to tables and rows.

Some applications are built around relationships.

Amazon Neptune provides a way to represent these relationships as a graph and query them using graph technologies.

The student course recommendation example helped me understand how graph databases can be applied to a real-world college scenario.

Conclusion

Amazon Neptune is an AWS managed graph database service designed for applications that work with highly connected data.

Its graph-based approach makes it useful for use cases such as recommendation systems, social networks, fraud detection, knowledge graphs, and network analysis.

For a college project, Neptune could be used to connect students, courses, skills, professors, departments, and projects and then discover useful relationships between them.

My main takeaway is simple:

When relationships between data are important, a graph database can provide a powerful way to model and explore those connections.

Amazon Neptune is therefore an interesting AWS service to explore for modern applications where connections matter as much as the data itself.

AWS Documentation References

Amazon Neptune Documentation:
https://docs.aws.amazon.com/neptune/
Amazon Neptune User Guide:
https://docs.aws.amazon.com/neptune/latest/userguide/
Amazon Neptune Features:
https://aws.amazon.com/neptune/features/
Amazon Neptune Pricing:
https://aws.amazon.com/neptune/pricing/
AWS Documentation:
https://docs.aws.amazon.com/

AWS #AmazonNeptune #GraphDatabase #CloudComputing #AWSCloud #Database #StudentProject #AWSLearning

# Day 1 – Session 2: EC2, Nginx, S3 CLI and Lambda Event Trigger

Nivetha Gopalakrishnan — Tue, 15 Sep 2026 16:34:54 +0000

In Day 1 – Session 2, I continued my AWS learning by working with Amazon EC2, Nginx, Amazon S3, AWS CLI, and AWS Lambda.

1. Create an EC2 Instance

The first task was to create an Amazon EC2 instance.

EC2 (Elastic Compute Cloud) provides virtual servers that can be used to run applications and services in AWS.

Steps

Log in to the AWS Management Console.
Search for EC2.
Click Launch instance.
Enter a name for the instance.
Select the required AMI.
Select the required instance type.
Create or select a key pair.
Configure the network and security group settings.
Launch the instance.

After completing these steps, the EC2 instance was successfully created and started.

2. Connect to the EC2 Instance

After launching the instance, I connected to it using SSH.

For an Ubuntu-based EC2 instance, the command is:

ssh -i "your-key.pem" ubuntu@<EC2-PUBLIC-IP>

After successfully connecting, I was able to access the EC2 server through the terminal.

3. Install Nginx

Next, I installed Nginx on the EC2 instance.

Nginx is a web server that can be used to serve websites and web applications.

For an Ubuntu-based instance, I used:

sudo apt update

Then I installed Nginx:

sudo apt install nginx -y

After installation, I started the Nginx service:

sudo systemctl start nginx

I also enabled Nginx to start automatically when the server starts:

sudo systemctl enable nginx

To check the status of Nginx:

sudo systemctl status nginx

Nginx was successfully installed and running on the EC2 instance.

4. Test Nginx

After installing Nginx, I opened the public IP address of the EC2 instance in a browser.

http://<13-233-163-95>

The default Nginx welcome page was displayed successfully.

This confirmed that the EC2 instance was working as a web server.

5. EC2 and S3 Using AWS CLI

Next, I worked on transferring files between EC2 and S3 using the AWS CLI.

I practiced both directions:

EC2 → S3
S3 → EC2

This helped me understand how EC2 can interact with S3 through command-line commands.

6. Transfer a File from EC2 to S3

First, I created a test file on the EC2 instance.

strangerthings.csv

Then I uploaded the file to the S3 bucket using the AWS CLI:

aws s3 cp strangerthings.csv s3://nivi-22034-15/

The file was successfully transferred from EC2 to S3.

To verify the file in the S3 bucket:

aws s3 ls s3://nivi-22034-15/

The file was listed successfully.

The flow was:

EC2
 |
 | AWS CLI
 v
S3 Bucket
 |
 └── strangerthings.csv

7. Transfer a File from S3 to EC2

Next, I tested the reverse process by downloading a file from S3 to EC2.

I used:

aws s3 cp s3://nivi-22034-15/strangerthings.csv .

The file was downloaded to the current directory of the EC2 instance.

To verify the file:

ls

To view the contents:

cat strangerthings.csv

The file was successfully transferred from S3 to EC2.

The flow was:

S3 Bucket
 |
 | AWS CLI
 v
EC2
 |
 └── strangerthings.csv

8. Create an AWS Lambda Function

After working with EC2 and S3, I moved on to AWS Lambda.

AWS Lambda allows us to run code without directly managing servers.

Steps

Open the AWS Management Console.
Search for Lambda.
Click Create function.
Select Author from scratch.
Enter the function name.
Select the required runtime.
Create the Lambda function.

The Lambda function was successfully created.

9. Configure an S3 Event Trigger

Next, I configured an S3 event trigger for the Lambda function.

The objective was to trigger the Lambda function whenever an object was deleted from the S3 bucket.

Steps

Open the Lambda function.
Go to the Function overview section.
Click Add trigger.
Select S3 as the trigger source.
Select the required S3 bucket.
Configure the event type.
Select the Object Deleted event.
Confirm the configuration.
Add the trigger.

The event flow was:

S3 Bucket
    |
    | Object Deleted
    v
AWS Lambda
    |
    v
Lambda Function Executes

10. Test the S3 Delete Trigger

After configuring the trigger, I tested it by deleting an object from the S3 bucket.

For example:

aws s3 rm s3://nivi-22034-15/test.txt

When the object was deleted, the S3 event triggered the Lambda function.

I then checked the Lambda logs to verify that the function was executed successfully.

This confirmed that the S3 Object Deleted event was successfully connected to the Lambda function.

11. Overall Workflow

The main workflow I implemented during this session was:

                    AWS
                     |
          +----------+----------+
          |                     |
         EC2                   S3
          |                     |
          | AWS CLI             |
          +-------------------->|
          |                     |
          |<--------------------+
          |                     |
          |              Object Deleted
          |                     |
          |                     v
          |                  Lambda
          |                     |
          |                     v
          |              Function Executes

12. What I Learned

In Day 1 – Session 2, I learned:

How to create an EC2 instance
How to connect to an EC2 instance using SSH
How to install Nginx
How to start and enable the Nginx service
How to access the Nginx server using the EC2 public IP
How to use AWS CLI from EC2
How to transfer files from EC2 to S3
How to transfer files from S3 to EC2
How to create an AWS Lambda function
How to configure an S3 event trigger
How to trigger Lambda when an S3 object is deleted
How to verify Lambda execution using logs

Conclusion

Day 1 – Session 2 gave me hands-on experience with EC2, Nginx, S3, AWS CLI, and Lambda.

I started by creating an EC2 instance and installing Nginx. I then used AWS CLI to transfer files between EC2 and S3.

Finally, I created a Lambda function and configured an S3 Object Deleted event trigger. After deleting an object from S3, I verified that the Lambda function was triggered successfully.

This session helped me understand how different AWS services can work together to build cloud-based applications.

AWS #EC2 #S3 #Lambda #Nginx #AWSCLI #CloudComputing #DevOps

Day 1 – Session 1: S3 Setup, Portfolio Hosting and CloudFront

Nivetha Gopalakrishnan — Tue, 15 Sep 2026 16:20:34 +0000

Today I learned how to create an Amazon S3 bucket, upload files, host a portfolio website, and configure Amazon CloudFront.

1. Create an S3 Bucket

First, I logged in to the AWS Management Console and opened the Amazon S3 service.

Steps:

Go to the AWS Console.
Search for S3.
Click Create bucket.
Enter a unique bucket name.

Example:

nivi-22034-15

Select the required AWS Region.
Keep the remaining settings as required.
Click Create bucket.

The S3 bucket was created successfully.

2. Upload the First Image

After creating the bucket, I uploaded an image to test S3 storage.

Steps:

Open the S3 bucket.
Click Upload.
Click Add files.
Select an image from the local computer.
Click Upload.
Verify that the image is available inside the bucket.

Example:

nivi-22034-15/
└── image.jpg

This helped me understand how files are stored as objects inside an S3 bucket.

3. Create and Upload the Portfolio `index.html`

After successfully uploading the image, I created a basic portfolio website using index.html.

The portfolio contains basic sections such as:

About Me
Skills
Projects
Contact

I then uploaded the index.html file to the S3 bucket.

The bucket structure became:

nivi-22034-15/
├── index.html
└── profile.jpg

4. Configure S3 for Static Website Hosting

Next, I configured the S3 bucket for static website hosting.

Steps:

Open the S3 bucket.
Go to the Properties tab.
Find Static website hosting.
Click Edit.
Select Enable.
Select Host a static website.
Enter the following:

Index document: index.html
Error document: 404.html

Click Save changes.

After saving the configuration, AWS provided an S3 website endpoint.

I opened the endpoint in the browser and verified that my portfolio was loading correctly.

5. Configure S3 Bucket Permissions

To access the website files, I configured the required S3 permissions.

I went to:

S3 → Bucket → Permissions

For the static website, I configured the bucket according to the required public-access settings.

I added the following bucket policy:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "PublicReadGetObject",
      "Effect": "Allow",
      "Principal": "*",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::nivi-22034-15/*"
    }
  ]
}

This policy allows users to read the objects stored inside the S3 bucket.

6. Test the Portfolio Website

After configuring S3, I opened the S3 website endpoint in a browser.

The index.html page loaded successfully, and I verified that the uploaded image was also displayed correctly.

The basic flow was:

Browser
   ↓
S3 Website Endpoint
   ↓
index.html
   ↓
Portfolio

7. Amazon CloudFront Configuration

After successfully hosting the portfolio on S3, I configured Amazon CloudFront.

CloudFront is a Content Delivery Network (CDN) provided by AWS. It helps deliver website content to users with lower latency and also supports HTTPS.

Steps:

Open the AWS Management Console.
Search for CloudFront.
Open the CloudFront service.
Click Create distribution.
Select the S3 bucket as the origin.
Select my S3 bucket:

nivi-22034-15

Configure the required origin settings.
Set the Default root object as:

index.html

Configure the required CloudFront settings.
Create the distribution.

CloudFront then generated a distribution domain name similar to:

https://xxxxxxxxxxxx.cloudfront.net

I opened the CloudFront URL in the browser and verified that my portfolio was loading successfully.

8. Final Setup

After completing the configuration, my portfolio was hosted using Amazon S3 and delivered through Amazon CloudFront.

The flow was:

User
 ↓
CloudFront
 ↓
S3 Bucket
 ↓
index.html
 ↓
Portfolio Website

9. What I Learned

In Day 1 – Session 1, I learned:

How to create an S3 bucket.
How to upload an image to S3.
How to upload index.html.
How to configure static website hosting.
How to configure an S3 bucket policy.
How to test a website using the S3 website endpoint.
What Amazon CloudFront is.
How to create a CloudFront distribution.
How to connect an S3 bucket with CloudFront.
How to set index.html as the default root object.
How to access the portfolio through the CloudFront URL.

Overall, this session gave me hands-on experience with Amazon S3 and CloudFront for hosting and delivering a static portfolio website.

AWS #S3 #CloudFront #AWSCloud #CloudComputing #DevOps #WebDevelopment #Portfolio

DEV Community: Nivetha Gopalakrishnan

Nivi Meets Neptune: Exploring Amazon Neptune☁️

Introduction

What Is Amazon Neptune?

Why Was Amazon Neptune Created?

How Does Amazon Neptune Work?

Key Features of Amazon Neptune

1. Graph Database

2. Support for Graph Models

3. Fully Managed AWS Service

4. High Availability and Scalability

5. AWS Integration

College / Student Use Case

Simple Practical Example

Advantages of Amazon Neptune

Relationship-Based Data

Managed Infrastructure

Flexible Graph Queries

AWS Ecosystem

Suitable for Complex Relationships

Limitations and Things to Consider

Cost

Complexity

Scalability Planning

Security

When Would I Choose Amazon Neptune?

What I Learned

Conclusion

AWS Documentation References

Tags

AWS #AmazonNeptune #GraphDatabase #CloudComputing #AWSCloud #Database #StudentProject #AWSLearning

# Day 1 – Session 2: EC2, Nginx, S3 CLI and Lambda Event Trigger

1. Create an EC2 Instance

Steps

2. Connect to the EC2 Instance

3. Install Nginx

4. Test Nginx

5. EC2 and S3 Using AWS CLI

6. Transfer a File from EC2 to S3

7. Transfer a File from S3 to EC2

8. Create an AWS Lambda Function

Steps

9. Configure an S3 Event Trigger

Steps

10. Test the S3 Delete Trigger

11. Overall Workflow

12. What I Learned

Conclusion

AWS #EC2 #S3 #Lambda #Nginx #AWSCLI #CloudComputing #DevOps

Day 1 – Session 1: S3 Setup, Portfolio Hosting and CloudFront

1. Create an S3 Bucket

Steps:

2. Upload the First Image

Steps:

3. Create and Upload the Portfolio index.html

4. Configure S3 for Static Website Hosting

Steps:

5. Configure S3 Bucket Permissions

6. Test the Portfolio Website

7. Amazon CloudFront Configuration

Steps:

8. Final Setup

9. What I Learned

AWS #S3 #CloudFront #AWSCloud #CloudComputing #DevOps #WebDevelopment #Portfolio

3. Create and Upload the Portfolio `index.html`