DEV Community: AKSHARANETHRA NP

Exploring Serverless Data Analytics on AWS(Athena)

AKSHARANETHRA NP — Wed, 16 Sep 2026 03:44:59 +0000

Akshara Meets Athena: Exploring Serverless Data Analytics on AWS

Tags: aws amazonathena cloudcomputing sql s3

In this blog, I explore Amazon Athena, a serverless AWS service that allows us to query data stored in Amazon S3 using SQL. I also demonstrate it using a Stranger Things dialogue dataset.

Introduction

Cloud computing provides many services for storing and analyzing data without requiring users to maintain physical infrastructure.

One such service is Amazon Athena, a serverless interactive query service from AWS. It allows users to analyze data stored in Amazon S3 using standard SQL, without setting up or managing database servers.

In this blog, I will explain what Amazon Athena is, why it was created, how it works, its key features, advantages and limitations. I will also demonstrate a practical use case using a Stranger Things dialogue dataset stored in Amazon S3.

What is Amazon Athena?

Amazon Athena is a serverless query service that allows users to run SQL queries directly on data stored in Amazon S3.

Unlike a traditional database, there is no need to create a database server before analyzing the data.

For example:

SELECT *
FROM stranger_things_dialogue
LIMIT 10;

Athena processes the query and returns the results without requiring us to manage the underlying servers.

Why Was Amazon Athena Created?

Organizations often store large amounts of data in Amazon S3. However, storing data in S3 alone does not provide a convenient way to perform SQL-based analysis.

A traditional approach could look like:

S3 → Database → SQL Query → Results

This requires additional infrastructure.

Athena provides a simpler approach:

S3 → Amazon Athena → SQL Query → Results

This makes it possible to analyze S3 data without provisioning or maintaining database infrastructure.

How Does Amazon Athena Work?

The working process is simple:

Data is stored in an Amazon S3 bucket.
Metadata about the data is defined using a table.
Athena uses the AWS Glue Data Catalog to store metadata.
The user writes an SQL query.
Athena reads the required data from S3.
The query results are displayed and can be stored in S3.

Architecture

                Student / User
                      |
                      | SQL Query
                      ↓
              +---------------+
              | Amazon Athena |
              +---------------+
                      |
                      ↓
             AWS Glue Data Catalog
                  (Metadata)
                      |
                      ↓
                +-----------+
                | Amazon S3 |
                |           |
                | CSV Data  |
                +-----------+
                      |
                      ↓
                Query Results

Figure: Basic Amazon Athena architecture

Key Features

1. Serverless

Athena is serverless, so there is no need to provision or manage servers.

This allows developers and students to focus on analyzing data instead of managing infrastructure.

2. SQL-Based Queries

Athena supports SQL, which makes it easy to query datasets using familiar commands such as:

SELECT
WHERE
GROUP BY
ORDER BY
COUNT()

3. Direct S3 Integration

Athena can query data directly from Amazon S3.

The original dataset can remain in S3 instead of being moved into a separate database.

4. Multiple Data Formats

Athena supports several data formats, including:

CSV
JSON
Parquet
ORC
Avro

5. Scalable Analytics

Athena can be used to analyze datasets ranging from small files to large data lakes without manually managing servers.

College / Student Use Case 🎓

Amazon Athena can be useful for college projects and departmental data analysis.

Example: Student Activity Analysis

Suppose a college stores student activity data in S3:

student_id
department
activity
timestamp

Athena could be used to analyze the data using SQL.

For example:

SELECT department, COUNT(*) AS activity_count
FROM student_activity
GROUP BY department;

This could help generate department-wise activity reports.

AIML Project Use Case

For an AIML student project, datasets can be stored in S3 and analyzed using Athena before being used for machine learning.

Dataset
   ↓
Amazon S3
   ↓
Amazon Athena
   ↓
Data Analysis
   ↓
Machine Learning

My Practical Example

For my hands-on demonstration, I used a Stranger Things dialogue dataset.

The dataset was downloaded from Kaggle and extracted on an Amazon EC2 instance.

The extracted files included:

episodes.csv
stranger_things_all_dialogue.csv

I then uploaded the dataset to my Amazon S3 bucket.

The S3 location was:

s3://akshara-s3-15-09-2026/stranger-things/

The files were successfully uploaded using the AWS CLI.

Querying the Dataset with Athena

After creating the appropriate Athena table, I can query the dataset using SQL.

Retrieve Sample Records

SELECT *
FROM stranger_things_dialogue
LIMIT 10;

This retrieves the first 10 records from the dataset.

Count Dialogue Records

SELECT COUNT(*) AS total_dialogues
FROM stranger_things_dialogue;

This calculates the total number of dialogue records.

Filter by Season

SELECT *
FROM stranger_things_dialogue
WHERE season = 1;

This retrieves dialogue records from Season 1.

Group by Character

SELECT character, COUNT(*) AS dialogue_count
FROM stranger_things_dialogue
GROUP BY character
ORDER BY dialogue_count DESC;

This allows us to analyze the number of dialogue records associated with each character.

Advantages

No Server Management

There is no need to create or maintain database servers.

Easy to Use

Users familiar with SQL can start querying data quickly.

Cost Efficient for Suitable Workloads

Athena follows a serverless pricing model and charges primarily based on the amount of data scanned by queries.

Works Well with Data Lakes

Athena is well suited for analyzing data stored in Amazon S3.

Flexible

It supports different data formats and integrates with other AWS services.

Limitations / Things to Consider

Cost

Because pricing is related to the amount of data scanned, inefficient queries on large datasets can increase costs.

Using partitioning and efficient formats such as Parquet can help reduce unnecessary data scanning.

Complexity

Basic queries are simple, but advanced workloads may require knowledge of SQL, data formats and data organization.

Not a Transactional Database

Athena is primarily designed for analytics. It is not intended to replace a traditional database for applications requiring frequent transactional operations.

Security

Access to S3 and Athena resources should be controlled using appropriate AWS IAM permissions. Sensitive data should also be protected using suitable S3 security configurations.

Conclusion

Amazon Athena provides a simple way to perform SQL-based analytics on data stored in Amazon S3.

In my practical demonstration, I uploaded a Stranger Things dialogue dataset to S3 and explored how Athena can be used to query and analyze the data using SQL.

The complete workflow can be summarized as:

Dataset
   ↓
Amazon S3
   ↓
AWS Glue Data Catalog
   ↓
Amazon Athena
   ↓
SQL Query
   ↓
Query Results

Amazon Athena demonstrates how cloud computing can make data analytics serverless, scalable and easier to manage.

For students, it is also a useful service for learning how S3-based data lakes and cloud analytics work.

References

Amazon Athena: Querying S3 Data Using SQL | A Hands-on AWS Guide

AKSHARANETHRA NP — Tue, 15 Sep 2026 16:41:53 +0000

Introduction

When working with large datasets in the cloud, analyzing data often requires setting up databases, servers, or data warehouses. Amazon Athena provides a simpler approach.

Amazon Athena is a serverless interactive query service that allows users to analyze data directly from Amazon S3 using standard SQL.

In this tutorial, we will:

Upload a dataset to Amazon S3
Create a database in Amazon Athena
Create a table for the dataset
Query the data using SQL
View and analyze the query results

For this demonstration, the Stranger Things Dialogue Dataset is used.

What is Amazon Athena?

Amazon Athena is a serverless query service provided by AWS that allows users to run SQL queries directly on data stored in Amazon S3.

Athena does not require:

Dedicated servers
Database installation
Infrastructure management
Database provisioning

You simply point Athena to your data in S3 and use SQL to query it.

Basic Architecture
User
|
↓
Amazon Athena
|
SQL Query
|
↓
Amazon S3 Dataset
|
↓
Query Result

Athena uses the AWS Glue Data Catalog to store information about databases and tables, while the actual data remains in Amazon S3.

Why Use Amazon Athena?

Athena is useful when you need to analyze data stored in S3 without creating and maintaining a traditional database.

Key advantages
Serverless – No servers to manage
SQL-based – Uses familiar SQL syntax
Direct S3 querying – Data can remain in S3
Scalable – Handles large datasets
Pay-per-query – Charges are based primarily on the amount of data scanned
Easy integration – Works with other AWS analytics services
Prerequisites

Before starting, you need:

An AWS account
An S3 bucket
A dataset stored in S3
Access to Amazon Athena
Basic knowledge of SQL

For this demonstration, the S3 bucket used is:

akshara-s3-15-09-2026

The dataset is stored under:

s3://akshara-s3-15-09-2026/stranger-things/

The uploaded files are:

episodes.csv
stranger-things-dialogue-dataset.zip
stranger_things_all_dialogue.csv

Note: In Athena, we will query the CSV file rather than the ZIP file.

Step 1: Upload the Dataset to Amazon S3

The dataset was first downloaded from Kaggle and extracted on an Amazon EC2 instance.

The extracted files were:

episodes.csv
stranger_things_all_dialogue.csv

They were then uploaded to S3 using the AWS CLI:

aws s3 cp . s3://akshara-s3-15-09-2026/stranger-things/ --recursive

To verify the uploaded files:

aws s3 ls s3://akshara-s3-15-09-2026/stranger-things/

The output confirmed that the files were successfully uploaded.

Step 2: Open Amazon Athena
Sign in to the AWS Management Console.
Search for Athena.
Open Amazon Athena.
Select the appropriate AWS Region.

You will be taken to the Athena Query Editor.

Screenshot:
Add screenshot of Amazon Athena Query Editor here.

Step 3: Configure the Query Result Location

Athena needs an S3 location where it can store the results of SQL queries.

In the Athena Query Editor:

Open Settings.
Find Query result location.
Specify an S3 path.

For example:

s3://akshara-s3-15-09-2026/athena-results/
Save the configuration.

The query results generated by Athena will be stored in this location.

Screenshot:
Add screenshot of Athena settings here.

Step 4: Create a Database

We can create a database using SQL.

Run:

CREATE DATABASE stranger_things_db;

After executing the query, select the database:

USE stranger_things_db;

The database provides a logical structure for organizing our tables.

Step 5: Create a Table

Now we need to tell Athena how the CSV file is structured.

Before creating the table, inspect the CSV file and identify its column names.

For example, if the dialogue dataset contains columns such as:

season
episode
character
dialogue

we can create a table using:

CREATE EXTERNAL TABLE stranger_things_dialogue (
season INT,
episode STRING,
character STRING,
dialogue STRING
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde'
WITH SERDEPROPERTIES (
'separatorChar' = ',',
'quoteChar' = '"'
)
LOCATION 's3://akshara-s3-15-09-2026/stranger-things/'
TBLPROPERTIES ('skip.header.line.count'='1');
Important

The column definitions must match the actual CSV structure.

If your CSV has different column names or data types, modify the CREATE TABLE statement accordingly.

Step 6: Verify the Table

To see the table:

SHOW TABLES;

You should see:

stranger_things_dialogue

You can also inspect the table structure:

DESCRIBE stranger_things_dialogue;

This displays the column names and their data types.

Step 7: Run the First Query

Let's retrieve some records from the dataset.

SELECT *
FROM stranger_things_dialogue
LIMIT 10;

Athena reads the data from S3 and returns the matching records.

Screenshot:
Add screenshot showing the query and results.

Step 8: Count the Number of Dialogue Records

We can use SQL aggregation to determine how many dialogue records exist.

SELECT COUNT(*) AS total_dialogues
FROM stranger_things_dialogue;

This demonstrates how Athena can perform analytical operations directly on S3 data.

Step 9: Find the Most Frequent Characters

We can use GROUP BY to determine which characters appear most frequently.

SELECT character, COUNT(*) AS dialogue_count
FROM stranger_things_dialogue
GROUP BY character
ORDER BY dialogue_count DESC;

This produces a ranking of characters based on the number of dialogue records.

Step 10: Filter Data

Athena supports standard SQL filtering.

For example:

SELECT *
FROM stranger_things_dialogue
WHERE season = 1;

This returns dialogue records belonging to Season 1.

We can also search for a particular word:

SELECT *
FROM stranger_things_dialogue
WHERE LOWER(dialogue) LIKE '%friends%';

This can be useful for text-based analysis.

Step 11: Aggregate Data by Season

We can calculate the number of dialogue records for each season.

SELECT season, COUNT(*) AS dialogue_count
FROM stranger_things_dialogue
GROUP BY season
ORDER BY season;

This allows us to compare dialogue volume across different seasons.

Step 12: Query Results

Athena displays the query results directly in the Query Editor.

The results can also be stored in Amazon S3 using the query result location configured earlier.

This allows the output of Athena queries to be reused by other AWS services or applications.

How Amazon Athena Works

The overall process can be summarized as:

    CSV Dataset
         |
         ↓
   Amazon S3
         |
         ↓
  AWS Glue Catalog
         |
         ↓
  Amazon Athena
         |
      SQL Query
         |
         ↓
   Query Results
         |
         ↓
   Amazon S3

Athena does not move the original dataset into a traditional database.

Instead, it reads the required data from S3 when a query is executed.

Athena and AWS Glue Data Catalog

Amazon Athena works with the AWS Glue Data Catalog to store metadata about datasets.

Metadata includes information such as:

Database name
Table name
Column names
Data types
S3 data location
File format

The actual dataset continues to reside in S3.

This separation between data and metadata makes Athena suitable for data-lake architectures.

Supported Data Formats

Athena can work with several data formats, including:

CSV
JSON
Apache Parquet
Apache ORC
Avro
Text files

For large-scale analytics, columnar formats such as Parquet can significantly improve query performance because Athena can scan only the required columns.

Advantages of Amazon Athena

Serverless

There is no infrastructure to provision or maintain.

Easy to Use

Users can analyze data using familiar SQL queries.

Direct S3 Integration

Athena can query data stored directly in Amazon S3.

Scalable

Athena can process datasets ranging from small files to very large data lakes.

Cost Efficient

There is no need to keep database servers running continuously.

Suitable for Data Lakes

Athena is particularly useful for analyzing large collections of data stored in S3.

Limitations

Although Athena is powerful, it has some limitations.

Query performance depends on data organization and file format.
Querying large CSV datasets can result in more data being scanned.
Poorly structured data can increase query cost.
Athena is primarily designed for analytics rather than high-frequency transactional workloads.

Using Parquet, partitioning, and efficient data organization can improve performance and reduce costs.

Real-World Applications

Amazon Athena can be used for:

Log analysis
Website analytics
Security analysis
Business intelligence
Data lake analytics
IoT data analysis
Financial data analysis
Application event analysis
Large-scale CSV/JSON data analysis

For example, an organization could store millions of application logs in S3 and use Athena to identify errors without maintaining a dedicated database server.

Amazon Athena vs Traditional Database
Feature Amazon Athena Traditional Database
Infrastructure Serverless Requires servers
Data Storage Amazon S3 Database storage
Query Language SQL SQL
Management Minimal Higher
Scaling Managed by AWS Usually configured
Best Use Analytics Transactional workloads
Data Lake Support Excellent Limited
Conclusion

Amazon Athena provides a simple and powerful way to analyze data stored in Amazon S3 using standard SQL.

In this hands-on demonstration, the Stranger Things dialogue dataset was:

Downloaded from Kaggle
Extracted on an EC2 instance
Uploaded to Amazon S3
Registered as an Athena table
Queried using SQL

The main advantage is that we can perform data analysis without creating or managing a database server.

This makes Amazon Athena an important service for serverless analytics and cloud-based data lake architectures.

Key Takeaways
Amazon S3 → Stores the data
AWS Glue → Stores metadata
Amazon Athena → Queries the data using SQL
Amazon S3 → Stores query results

Amazon Athena enables serverless SQL-based analytics directly on data stored in Amazon S3.

References
Amazon Athena Documentation
Amazon S3 Documentation
AWS Glue Data Catalog

AWS Hands-on workshop

AKSHARANETHRA NP — Tue, 15 Sep 2026 06:51:53 +0000

AWS Workshop – Day 1, Session 1

Deploying a Portfolio Website Using AWS S3 and CloudFront

In the first session of the AWS workshop, I learned how to deploy a static website using Amazon S3 and make it accessible globally using Amazon CloudFront.

1. Creating the Portfolio

I first created a personal portfolio website containing sections such as my profile, skills, education, projects, and contact information.

2. Hosting Using Amazon S3

I created an Amazon S3 bucket and uploaded all the portfolio files, including HTML, CSS, JavaScript, and images.

The bucket was configured for static website hosting, allowing the portfolio to be accessed through an S3 website endpoint.

3. Global Deployment Using CloudFront

Next, I created an Amazon CloudFront distribution with the S3 bucket as the origin.

CloudFront is a Content Delivery Network (CDN) that delivers website content through globally distributed edge locations. This helps reduce latency and improves website performance for users in different locations.

Deployment Architecture

Portfolio Website
       ↓
   Amazon S3
       ↓
 Amazon CloudFront
       ↓
   Global Users

Key Learnings

Through this hands-on session, I learned how to:

Create and configure an S3 bucket
Upload and host a static website
Create a CloudFront distribution
Deploy a website for global content delivery

Conclusion

This session gave me practical experience in AWS cloud deployment, from storing website files in S3 to distributing the portfolio globally using CloudFront.