You just hit a route that doesn't exist... the sadness.
diff --git a/src/pages/blog/2024-04-25-discovering-the-inner-workings-of-postgresqls-data-allocation.md b/src/pages/blog/2024-04-25-discovering-the-inner-workings-of-postgresqls-data-allocation.md
new file mode 100644
index 000000000..81dd705f2
--- /dev/null
+++ b/src/pages/blog/2024-04-25-discovering-the-inner-workings-of-postgresqls-data-allocation.md
@@ -0,0 +1,63 @@
+---
+templateKey: blog-post
+title: Discovering the Inner Workings of PostgreSQL's Data Allocation
+date: 2024-04-25T08:29:55.344Z
+description: PostgreSQL is a true gem among open-source relational database
+ management systems. Its impressive robustness, flexibility, and scalability
+ make it a favourite choice for many developers and businesses alike. One of
+ the most crucial components of any database system is how it manages and
+ allocates data. In this article, we'll take a deep dive into PostgreSQL's data
+ allocation process to reveal its inner workings and discover how it ensures
+ optimal performance and reliability.
+featuredpost: true
+featuredimage: /img/logo.png
+---
+
+
+PostgreSQL is a true gem among open-source relational database management systems. Its impressive robustness, flexibility, and scalability make it a favourite choice for many developers and businesses alike. One of the most crucial components of any database system is how it manages and allocates data. In this article, we'll take a deep dive into PostgreSQL's data allocation process to reveal its inner workings and discover how it ensures optimal performance and reliability.
+
+1. The Art of Data Storage:
+
+PostgreSQL stores data in tables, with each table containing data rows. Each row is made up of one or more columns representing various attributes of the data. When you create a PostgreSQL table, you must define its schema, specifying data types and constraints for each column. It's like giving your data a personality and a set of rules to follow.
+
+2. The Science of Storage Management:
+
+PostgreSQL's storage management strategy involves breaking data into smaller chunks, or pages. Each page is like a container with a fixed capacity, and PostgreSQL organizes data by placing it into these containers. Just like arranging items in multiple containers makes it easier to manage them, PostgreSQL's page-based storage allows for efficient data organization.
+
+3. Tablespaces: A World of Possibilities
+
+ PostgreSQL organizes data into tablespaces, each representing a physical location on the disk where data is stored. A PostgreSQL database can have multiple tablespaces, allowing you to distribute data across different physical disks or file systems. This feature enhances performance and enables better control over storage resources. An example is having a house with multiple rooms, each with its unique purpose.
+
+4. Heap Files: The Foundation of PostgreSQL's Data Storage
+
+ PostgreSQL stores data in heap files when you create a table. A heap file is an uncomplicated append-only file containing a series of data pages. When you insert new rows into a table, PostgreSQL appends the data to the heap file's pages, ensuring that new data is always written sequentially. This approach reduces fragmentation and optimizes disk I/O performance for write operations. It's reminiscent of having a notebook where you write your thoughts in chronological order.
+
+5. Page Structure: The Building Blocks of PostgreSQL's Data Allocation
+
+PostgreSQL employs a page structure within each heap file to organize data efficiently. Each page consists of a header, containing metadata about the page, followed by the actual data rows. The header includes information such as the page number, the number of items stored on the page, and a pointer to the next page. Imagine having a folder with labels for each paper inside.
+
+6. The Magic of Data Allocation:
+
+PostgreSQL automatically manages data allocation when you insert data into a table. When a new row is added, PostgreSQL determines the appropriate page to allocate the data. If the existing page has enough space to accommodate the new row, it will place it there. Otherwise, it will create a new page and link it to the existing pages to form a chain. It's like having a magician that knows all the tricks to make your data disappear and reappear in the right place.
+
+ 7. Free Space Map (FSM): The Map to Your Data's Destination
+
+To keep track of available space within each page, PostgreSQL maintains a Free Space Map (FSM). The FSM records which bytes within each page are used and which ones are still available for data allocation. When inserting or updating data, PostgreSQL checks the FSM to find the page with sufficient free space. It's like having a treasure map that leads you to the right spot.
+
+8. Indexes and Data Allocation: The Key to Your Data's Acceleration
+
+PostgreSQL's indexing mechanism plays a vital role in data allocation efficiency. When you create an index on a table, PostgreSQL creates a separate B-tree data structure that allows for faster data retrieval based on the indexed columns. The presence of indexes influences how PostgreSQL allocates data to maintain optimal access and search performance. It’s the same as having a GPS that guides you to the quickest route.
+
+9. Apache AGE: Expanding PostgreSQL with Graph Database Functionality
+
+While PostgreSQL excels in managing relational data, its capabilities extend into the realm of graph databases, thanks to its integration with Apache AGE (A Graph Extension). Apache AGE is an extension that transforms PostgreSQL into a graph database, allowing it to handle complex, connected data structures alongside traditional relational data. This integration offers the best of both worlds – the robust, tried-and-tested features of PostgreSQL for relational data, and the flexibility of graph database capabilities for handling interconnected data. Think of it as adding an advanced toolset to an already well-equipped toolbox, making PostgreSQL not just a database, but a versatile data processing engine.
+
+With Apache AGE, PostgreSQL becomes an even more powerful option for developers needing to manage diverse data models, from social networks to recommendation systems, without sacrificing the reliability and performance PostgreSQL is known for. This seamless blending of technologies demonstrates PostgreSQL's adaptability and its commitment to evolving with the changing landscape of data management.
+
+\*\**
+
+In conclusion, PostgreSQL's data allocation process is a fascinating and efficient system that ensures optimal performance and data organization. By dividing data into manageable pages, employing tablespaces for better storage management, and utilizing indexing mechanisms, PostgreSQL offers a reliable and scalable solution for handling large volumes of data. Understanding how PostgreSQL manages data allocation is crucial for database administrators and developers to optimize their applications and make the most out of this powerful database management system. Let's build a better world of data together!
+
+
+
+
\ No newline at end of file
diff --git a/src/pages/blog/2024-04-25-how-to-deploy-apache-age-docker-image-on-aws.md b/src/pages/blog/2024-04-25-how-to-deploy-apache-age-docker-image-on-aws.md
new file mode 100644
index 000000000..e49bb2376
--- /dev/null
+++ b/src/pages/blog/2024-04-25-how-to-deploy-apache-age-docker-image-on-aws.md
@@ -0,0 +1,89 @@
+---
+templateKey: blog-post
+title: How to Deploy Apache AGE Docker Image on AWS
+date: 2024-04-25T08:37:04.997Z
+description: >
+ Apache AGE® is a PostgreSQL extension that provides graph database
+ functionality. Apache AGE provides graph data processing and analytics
+ capability to all relational databases.
+
+ This article will explore how to set up Amazon Web Services (AWS), deploy the Apache AGE Docker image, and query the PostgreSQL database running in the Docker container on Amazon Web Services (AWS).
+featuredpost: true
+featuredimage:
+---
+
+
+Apache AGE® is a PostgreSQL extension that provides graph database functionality. Apache AGE provides graph data processing and analytics capability to all relational databases.
+
+This article will explore how to set up Amazon Web Services (AWS), deploy the Apache AGE Docker image, and query the PostgreSQL database running in the Docker container on Amazon Web Services (AWS).
+
+Prerequisites
+
+1. AWS Account: If you don’t already have one, sign up for an AWS account at [Amazon Web Services](https://aws.amazon.com/).
+2. Docker: Install Docker on your local machine. You can download & install Docker from [here](https://www.docker.com/get-started).
+
+
+
+Step 1: Set Up AWS Account
+
+1. Log in to AWS: Access the AWS Management Console using your AWS account credentials.
+2. Create an IAM User:
+3. 1. Navigate to the IAM (Identity and Access Management) dashboard.
+ 2. Click on “Users” & then “Add user.”
+ 3. Provide a username and select “Programmatic access” to generate an access key and secret key for Docker authentication.
+
+Step 2: Deploy Apache AGE Docker Image
+
+1. Open a terminal on your local machine.
+2. Pull the Apache AGE Docker image from Docker Hub: 
+3. Run the Docker container locally to verify its functionality: 
+4. Tag the Docker image with the Amazon Elastic Container Registry (ECR) repository URL: 
+5. Authenticate Docker to the Amazon ECR:
+6. Push the Docker image to your Amazon ECR repository: 
+
+
+
+Step 3: Launch the Amazon EC2 Instance
+
+1. In the AWS Management Console, go to the EC2 Dashboard.
+2. Click “Launch Instance” and choose an Amazon Machine Image (AMI) of your choice.
+3. Configure the instance settings:
+4. * Choose an instance type.
+ * Configure instance details and storage.
+ * Add tags if necessary.
+ * Configure security group rules to allow incoming traffic on port 5432 (PostgreSQL).
+5. Review the configurations and launch the instance.
+
+
+
+Step 4: Deploy Docker Image on Amazon EC2
+
+1. SSH into your Amazon EC2 instance using the key pair associated with the instance:
+2. Install Docker on the EC2 instance:
+
+
+
+
+
+
+
+
+
+3. Pull and run the Apache AGE Docker image on the instance:
+
+
+
+Step 5: Access & Query PostgreSQL Database
+
+1. Install the PostgreSQL client on the EC2 instance:
+2. Connect to the Postgres database running in the Docker container:
+
+You are now connected to the PostgreSQL database. Execute SQL queries and interact with the database as needed.
+
+Conclusion
+
+By following this comprehensive guide, you have successfully set up an AWS account, deployed the Apache AGE Docker image on an Amazon EC2 instance, and accessed the PostgreSQL database within the Docker container. This setup provides a secure and scalable environment for your data encryption and storage needs.
+
+
+
+
\ No newline at end of file
diff --git a/src/pages/blog/2024-04-25-seamless-data-migration-migrating-apache-age-data-between-different-versions-of-postgresql.md b/src/pages/blog/2024-04-25-seamless-data-migration-migrating-apache-age-data-between-different-versions-of-postgresql.md
new file mode 100644
index 000000000..46c8adfaa
--- /dev/null
+++ b/src/pages/blog/2024-04-25-seamless-data-migration-migrating-apache-age-data-between-different-versions-of-postgresql.md
@@ -0,0 +1,164 @@
+---
+templateKey: blog-post
+title: "Seamless Data Migration: Migrating Apache AGE Data Between Different
+ Versions of PostgreSQL"
+date: 2024-04-25T08:33:00.464Z
+description: >
+ Apache AGE serves as an open-source graph database, akin to Neo4j. Although
+ they share similar functionalities, they also exhibit significant differences.
+ AGE stands out as a PostgreSQL extension which leverages the capabilities of a
+ relational database (RDBMS), enabling users to seamlessly integrate both
+ relational data (tables) and graph data, which is a key strength setting it
+ apart from Neo4j.
+featuredpost: true
+featuredimage:
+---
+
+
+Apache AGE serves as an open-source graph database, akin to Neo4j. Although they share similar functionalities, they also exhibit significant differences. AGE stands out as a PostgreSQL extension which leverages the capabilities of a relational database (RDBMS), enabling users to seamlessly integrate both relational data (tables) and graph data, which is a key strength setting it apart from Neo4j.
+
+
+
+AGE is available in various versions, each compatible with specific PostgreSQL versions. One common challenge users encounter is data migration when transitioning from one AGE version to another. Fortunately, PostgreSQL provides a utility called "pg_dump", which seamlessly functions with AGE for data migration.
+
+
+
+Let's exemplify the data migration process by creating a graph with some nodes:
+
+
+
+SELECT create_graph('test');
+
+
+
+NOTICE: graph "test" has been created
+
+ create_graph
+
+\--------------
+
+
+
+(1 row)
+
+
+
+SELECT * FROM cypher('test', $$
+
+ CREATE (:Person {name: "John Doe"})
+
+ CREATE (:Person {name: "Jane Smith"})
+
+$$) AS (res agtype);
+
+
+
+ res
+
+\-----
+
+(0 rows)
+
+
+
+SELECT * FROM cypher('test', $$
+
+ MATH (n)
+
+ RETURN n
+
+$$) AS (res agtype);
+
+
+
+ res
+
+\----------------------------------------------------------------------------
+
+ {"id": 1, "label": "Person", "properties": {"name": "John Doe"}}::vertex
+
+ {"id": 2, "label": "Person", "properties": {"name": "Jane Smith"}}::vertex
+
+(2 rows)
+
+
+
+Now, we have a graph called "test" containing two vertices (keeping it simple).
+
+
+
+Using pg_dump for Backup:
+
+
+
+To create a backup, open a new terminal in your current postgreSQL directory and execute the following command:
+
+
+
+bin/pg_dump -d postgres > age_backup.sql
+
+
+
+Here, "postgres" represents the name of the database (which might differ in your case), and "age_backup" is the chosen name for this demonstration. The generated "age_backup.sql" file will contain all the necessary queries to restore this backup whenever needed.
+
+
+
+Now, if you open “age_backup.sql”, which will be in your PostgreSQL directory, its initial content will resemble this:
+
+
+
+\-- PostgreSQL database dump
+
+\-- Dumped from database version 13.9
+
+\-- Dumped by pg_dump version 13.9
+
+
+
+Using psql for Migration:
+
+
+
+Navigate to the directory containing the desired version of PostgreSQL in your terminal—the one to which you intend to migrate the data. Ensure that you have also installed the desired version of AGE as well.
+
+
+
+Execute the following command:
+
+
+
+bin/psql -d postgres-f path/to/age_dump.sql
+
+
+
+Now, it's time to check whether the data migration has been successfully executed. To do this, enter the following command in the psql terminal:
+
+
+
+SELECT * FROM cypher('test', $$
+
+ MATH (n)
+
+ RETURN n
+
+$$) AS (res agtype);
+
+
+
+ res
+
+\----------------------------------------------------------------------------
+
+ {"id": 1, "label": "Person", "properties": {"name": "John Doe"}}::vertex
+
+ {"id": 2, "label": "Person", "properties": {"name": "Jane Smith"}}::vertex
+
+(2 rows)
+
+
+
+As you can see, the data has been successfully migrated to the new version of AGE.
+
+
+
+
\ No newline at end of file
diff --git a/src/pages/index.md b/src/pages/index.md
index d8c07f23e..0ac4217ee 100644
--- a/src/pages/index.md
+++ b/src/pages/index.md
@@ -1,10 +1,9 @@
---
templateKey: index-page
-title: Apache AGE | Graph Database for PostgreSQL
+title: Apache AGE | Apache AGE Graph Database for PostgreSQL
bannerImg: /img/background.webp
bannerContents: >-
-