Merge pull request #190 from nvillahermosa-mdb/DOCSP-45944-rm-homepage-update

DOCSP-45944 rm homepage update

Author: nvillahermosa-mdb

source/diagrams/diagrams.txt

@@ -10,36 +10,26 @@ Diagrams
    :depth: 2
    :class: singlecol
 
-Diagrams function as an Entity Relationship Diagram (ERD) tool to
-visualize tables, foreign key relationships, and data types. Diagrams
-help you understand the relational database's schema, and show you how
-to best represent relational data in MongoDB. Diagrams also show how
-your mapping rules shape the target MongoDB schema.
+A project's :guilabel:`Mapping` screen maintains entity-relationship diagrams
+that show tables, foreign key relationships, and data types. This helps you
+optimize how you represent your relational data in MongoDB. Diagrams also
+let you see how your mapping rules shape your MongoDB schema.
 
 When you finish :ref:`creating a migration project
 <rm-create-project-live>`, Relational Migrator creates a new diagram
-based on your project's mapping rules. The diagram is comprised of two
-views:
+based on your mapping rules. 
 
-- A Relational view, representing the tables in your relational
-  database
+Each diagram has two views:
 
-- A MongoDB view, representing the collections in your target MongoDB
-  database
+- The :guilabel:`Relational` view represents the tables in your relational
+  database. This view updates if you change your project's data model.
 
-When you :ref:`edit mapping rules <mapping-rules-edit>` for your
-project, the MongoDB view automatically updates to reflect the new
-rules.
+- The :guilabel:`MongoDB` view represents the collections in your MongoDB
+  database. This view updates if you :ref:`change your project's mapping rules <mapping-rules-edit>`.
 
-The relational view is unaffected by mapping rules, and only changes
-when you update your project's data model.
+You can also use `Hackolade <https://hackolade.com/>`__ to visualize your schemas.
 
-.. tip::
-
-  You can also use `Hackolade <https://hackolade.com/>`__ to 
-  visualize your schemas.
-
-  .. include:: /includes/fact-hackolade-integration.rst
+.. include:: /includes/fact-hackolade-integration.rst
 
 Get Started
 -----------

source/diagrams/manage-diagrams.txt

@@ -10,8 +10,7 @@ Manage Diagrams
    :depth: 1
    :class: singlecol
 
-The following pages outline the details and specifics of how to manage
-diagrams in Relational Migrator.
+You can create new entity-relationship diagrams from the :guilabel:`Mapping` screen, or clone, rename, or delete existing diagrams.
 
 Get Started
 -----------

source/diagrams/manage-diagrams/create-diagrams.txt

@@ -24,7 +24,7 @@ About this Task
 - After you create a diagram, you can
   :ref:`clone <rm-clone-diagrams>`, :ref:`rename <rm-rename-diagrams>`,
   and :ref:`delete <rm-delete-diagrams>` your new diagram. 
-- You must have at least one digram on your Diagram Toolbar. 
+- You must have at least one diagram on your Diagram Toolbar. 
 - Relational Migrator includes diagrams when you import and export
   projects. 
 

source/img/convert-sql.png

@@ -1,7 +1,21 @@
-MongoDB Relational Migrator is a tool to help you migrate relational workloads to MongoDB. 
-Relational Migrator allows you to:
+MongoDB Relational Migrator is a free tool to help you migrate data from a
+relational database to MongoDB. With Relational Migrator, you can:
 
-- Design an effective MongoDB schema derived from an existing relational schema.
-- Migrate data from Oracle, SQL Server, MySQL, PostgreSQL, or Sybase ASE
-  to MongoDB, while transforming to the target schema.
-- Generate code artifacts to reduce the time required to update application code.
+- **Transform your data** 
+  
+  Define a new MongoDB schema for your data, or start with a recommended one 
+  and customize it to suit your needs.
+  
+- **Easily migrate to MongoDB** 
+  
+  Migrate data from popular relational databases like Oracle, SQL Server,
+  MySQL, PostgreSQL, :ref:`and others <supported-databases>` to MongoDB Atlas 
+  or a self-managed deployment.
+
+- **Generate application code** 
+
+  Get MongoDB-compatible code for entity classes, persistence layers, and APIs.
+
+- **Convert SQL database objects with Generative AI** 
+
+  Convert SQL queries, procedures, and views -- then, validate them.

source/img/tab4img.png renamed to source/img/generated-code.png

@@ -16,97 +16,98 @@ What is Relational Migrator
       :uri: https://www.mongodb.com/try/download/relational-migrator
 
 .. image:: /img/hero.png
-   :alt: Homepage hero image
+   :alt: An image of documents moving from one stack to another
 
 .. kicker:: What You Can Do
 
-Bring Your Relational Workloads to MongoDB With Confidence
-----------------------------------------------------------
+Migrate Your Relational Workloads to MongoDB
+--------------------------------------------
 
 .. tabs::
 
-   .. tab:: Mapping and Modelling
-      :tabid: mapping-mod
+   .. tab:: Map and Model Data
+      :tabid: mapping-modeling
 
       .. procedure::
 
-         .. step:: Visualize Source and Destination Schemas
+         .. step:: Design Your New Schema
 
+            Use the :ref:`Mapping screen's <rm-diagrams>`
+            entity-relationship diagrams to define a new schema,
+            or start with a recommended schema and customize it. :ref:`Define
+            new fields <rm-calculated-fields>`, split or merge table data, or
+            denormalize foreign key relationships as :ref:`embedded documents
+            <rm-embedded-documents>` and :ref:`arrays <rm-embedded-array>`.
 
-            Use the entity-relationship style :ref:`diagramming interface <rm-diagrams>` 
-            to visualize your schema and make schema mapping decisions.
+         .. step:: Apply Custom Mapping Rules
 
-         .. step:: Customize While Migrating
-
-            Split or merge tables across collections. 
-            Embed a table as a :ref:`nested document <rm-embedded-documents>`
-            or :ref:`array <rm-embedded-array>` in an existing collection. 
-            Define :ref:`custom JavaScript expressions <rm-calculated-fields>` 
-            to create additional fields.
+            Use custom :ref:`mapping rules <rm-mapping-rules>` to denormalize
+            your relational schema, or incorporate multiple tables into a
+            single MongoDB collection for improved data access and query performance.
 
       .. image:: /img/tab1img.png
-         :alt: Mapping and Modelling
+         :alt: An entity-relationship diagram in Relational Migrator
+
 
-   .. tab:: Schema Recommendations
-      :tabid: schema-rec
+   .. tab:: Migrate to MongoDB
+      :tabid: migrate-data
 
       .. procedure::
 
-         .. step:: Get Suggested Schema Recommendations
+         .. step:: Migrate From Your Relational Database
 
-            Accelerate your schema mapping by asking Relational
-            Migrator to :ref:`suggest a MongoDB schema <rm-new-rules-from-mappings>` 
-            for your workload, or start with a blank slate.
+            Migrate data from relational databases like Oracle, SQL
+            Server, MySQL, PostgreSQL, :ref:`and others <supported-databases>`
+            to MongoDB Atlas or a self-managed deployment.
 
+         .. step:: Migrate Once, or Synchronize
 
-         .. step:: Apply your Mapping Rules
+            Choose between a snapshot migration, or continuous synchronization
+            with Change Data Capture (CDC). Verify data integrity within
+            Relational Migrator and integrate with Apache Kafka or Confluent
+            Cloud for large-scale migrations.
 
-            Quickly apply recommended table mappings 
-            to a specific collection in your model.
+      .. image:: /img/new-migration-job.png
+         :alt: The data migration UI in Relational Migrator
 
-      .. image:: /img/tab2img.png
-         :alt: Schema Recommendations
 
-   .. tab:: Data Synchronization
-      :tabid: data-sync
+   .. tab:: Get Application Code
+      :tabid: convert-application-code
 
       .. procedure::
+         
+         .. step:: Select a Language and Framework
+            
+            Choose from languages like C#, Java, and JavaScript.
+            Code generation templates support JSON output and common
+            application frameworks like Spring Data, Node, Mongoose, and
+            :ref:`more <rm-code-generation-templates>`.
 
+         .. step:: Automatically Generate Application Code
+            
+            Instantly generate MongoDB-compatible application code for entity classes, persistence layers, and APIs.
 
-         .. step:: Replicate From Supported Relational Systems
-
-            Replicate data from Oracle, MySQL, SQL Server, PostgreSQL,
-            or Sybase ASE to MongoDB Atlas or on-premises.
-
-         .. step:: Transform Data as Its Replicated
-
-            Use the saved :ref:`mapping definitions <rm-mapping-rules>` 
-            to transform data to the MongoDB schema as it's replicated.
-            Replication can be one time or continuous.
+      .. image:: /img/generated-code.png
+         :alt: A generated code example
 
-      .. image:: /img/tab3img.png
-         :alt: Data synchronization
 
-   .. tab:: Convert your Application Code
-      :tabid: convert-application-code
+   .. tab:: Convert and Validate SQL Objects
+      :tabid: convert-sql-objects
 
       .. procedure::
 
-         .. step:: Pick a Language and Template
+         .. step:: Use Generative AI to Convert SQL Database Objects
 
-            Support for popular enterprise languages including C#, Java, 
-            JavaScript, JSON, and :ref:`multiple template frameworks <rm-code-generation-templates>`.
+            :ref:`Convert <rm-query-converter>` SQL queries, views, and stored procedures into MongoDB-compatible code for C#, Java, or JavaScript.
 
+         .. step:: Validate Converted Code
+            
+            Test queries within Relational Migrator to validate converted SQL and ensure compatibility with MongoDB.
 
-         .. step:: Automatically Generate Application Code
-
-            Use information about the new schema to accelerate 
-            :ref:`new code development <rm-download-all-code-files>`. 
-            Includes code generation of entity classes, persistence layers, and APIs.
+      .. image:: /img/convert-sql.png
+         :alt: A query converted from SQL to MQL
 
 
-      .. image:: /img/tab4img.png
-         :alt: Convert your Application Code
 
 .. kicker:: Related Products & Resources