diff --git a/doc/release-notes/10943-featured-items.md b/doc/release-notes/10943-featured-items.md
new file mode 100644
index 00000000000..fa61d4e4875
--- /dev/null
+++ b/doc/release-notes/10943-featured-items.md
@@ -0,0 +1,15 @@
+CRUD endpoints for Collection Featured Items have been implemented. In particular, the following endpoints have been implemented:
+
+- Create a feature item (POST /api/dataverses/<dataverse_id>/featuredItems)
+- Update a feature item (PUT /api/dataverseFeaturedItems/<item_id>)
+- Delete a feature item (DELETE /api/dataverseFeaturedItems/<item_id>)
+- List all featured items in a collection (GET /api/dataverses/<dataverse_id>/featuredItems)
+- Delete all featured items in a collection (DELETE /api/dataverses/<dataverse_id>/featuredItems)
+- Update all featured items in a collection (PUT /api/dataverses/<dataverse_id>/featuredItems)
+
+New settings:
+
+- dataverse.files.featured-items.image-maxsize - It sets the maximum allowed size of the image that can be added to a featured item.
+- dataverse.files.featured-items.image-uploads - It specifies the name of the subdirectory for saving featured item images within the docroot directory.
+
+See also #10943 and #11124.
diff --git a/doc/sphinx-guides/source/api/native-api.rst b/doc/sphinx-guides/source/api/native-api.rst
index 7cd84565cbd..76682d1cec8 100644
--- a/doc/sphinx-guides/source/api/native-api.rst
+++ b/doc/sphinx-guides/source/api/native-api.rst
@@ -1156,6 +1156,209 @@ Use the ``/settings`` API to enable or disable the enforcement of storage quotas
 
    curl -X PUT -d 'true' http://localhost:8080/api/admin/settings/:UseStorageQuotas
 
+List All Collection Featured Items
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+List the featured items configured for a given Dataverse collection ``id``:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=root
+
+  curl -H "X-Dataverse-key:$API_TOKEN" "$SERVER_URL/api/dataverses/$ID/featuredItems"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" "https://demo.dataverse.org/api/dataverses/root/featuredItems"
+
+Update All Collection Featured Items
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Updates all featured items in the given Dataverse collection ``id``.
+
+The data sent to the endpoint represents the desired final state of the featured items in the Dataverse collection and overwrites any existing featured items configuration.
+
+The parameters ``id``, ``content``, ``displayOrder``, and ``fileName`` must be specified as many times as the number of items we want to add or update. The order in which these parameters are repeated must match to ensure they correspond to the same featured item.
+
+The ``file`` parameter must be specified for each image we want to attach to featured items. Note that images can be shared between featured items, so ``fileName`` can have the same value in different featured items.
+
+The ``id`` parameter must be ``0`` for new items or set to the item's identifier for updates. The ``fileName`` parameter should be empty to exclude an image or match the name of a file sent in a ``file`` parameter to set a new image. ``keepFile`` must always be set to ``false``, unless it's an update to a featured item where we want to preserve the existing image, if one exists.
+
+Note that any existing featured item not included in the call with its associated identifier and corresponding properties will be removed from the collection.
+
+The following example creates two featured items, with an image assigned to the second one:
+
+.. code-block:: bash
+
+    export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+    export SERVER_URL=https://demo.dataverse.org
+    export ID=root
+
+    export FIRST_ITEM_CONTENT='Content 1'
+    export FIRST_ITEM_DISPLAY_ORDER=1
+
+    export SECOND_ITEM_IMAGE_FILENAME='image.png'
+    export SECOND_ITEM_CONTENT='Content 2'
+    export SECOND_ITEM_DISPLAY_ORDER=2
+
+    curl -H "X-Dataverse-key:$API_TOKEN" \
+         -X PUT \
+         -F "id=0" -F "id=0" \
+         -F "content=$FIRST_ITEM_CONTENT" -F "content=$SECOND_ITEM_CONTENT" \
+         -F "displayOrder=$FIRST_ITEM_DISPLAY_ORDER" -F "displayOrder=$SECOND_ITEM_DISPLAY_ORDER" \
+         -F "fileName=" -F "fileName=$SECOND_ITEM_IMAGE_FILENAME" \
+         -F "keepFile=false" -F "keepFile=false" \
+         -F "file=@$SECOND_ITEM_IMAGE_FILENAME" \
+         "$SERVER_URL/api/dataverses/$ID/featuredItems"
+
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+    curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" \
+         -X PUT \
+         -F "id=0" -F "id=0" \
+         -F "content=Content 1" -F "content=Content 2" \
+         -F "displayOrder=1" -F "displayOrder=2" \
+         -F "fileName=" -F "fileName=image.png" \
+         -F "keepFile=false" -F "keepFile=false" \
+         -F "file=@image.png" \
+         "https://demo.dataverse.org/api/dataverses/root/featuredItems"
+
+The following example creates one featured item and updates a second one, keeping the existing image it may have had:
+
+.. code-block:: bash
+
+    curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" \
+         -X PUT \
+         -F "id=0" -F "id=1" \
+         -F "content=Content 1" -F "content=Updated content 2" \
+         -F "displayOrder=1" -F "displayOrder=2" \
+         -F "fileName=" -F "fileName=" \
+         -F "keepFile=false" -F "keepFile=true" \
+         "https://demo.dataverse.org/api/dataverses/root/featuredItems"
+
+Delete All Collection Featured Items
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Deletes the featured items configured for a given Dataverse collection ``id``:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=root
+
+  curl -H "X-Dataverse-key: $API_TOKEN" -X DELETE "$SERVER_URL/api/dataverses/$ID/featuredItems"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X DELETE "https://demo.dataverse.org/api/dataverses/root/featuredItems"
+
+Create a Collection Featured Item
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Creates a featured item in the given Dataverse collection ``id``:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export IMAGE_FILENAME='image.png'
+  export CONTENT='Content for featured item.'
+  export DISPLAY_ORDER=1
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=root
+
+  curl -H "X-Dataverse-key:$API_TOKEN" -X POST -F "file=@$IMAGE_FILENAME" -F "content=$CONTENT" -F "displayOrder=$DISPLAY_ORDER" "$SERVER_URL/api/dataverses/$ID/featuredItems"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X POST -F "file=@image.png" -F "content=Content for featured item." -F "displayOrder=1" "https://demo.dataverse.org/api/dataverses/root/featuredItems"
+
+A featured item may or may not contain an image. If you wish to create it without an image, omit the file parameter in the request.
+
+Update a Collection Featured Item
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Updates a featured item given its ``id``:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export IMAGE_FILENAME='image.png'
+  export CONTENT='Content for featured item.'
+  export DISPLAY_ORDER=1
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=1
+
+  curl -H "X-Dataverse-key:$API_TOKEN" -X PUT -F "file=@$IMAGE_FILENAME" -F "content=$CONTENT" -F "displayOrder=$DISPLAY_ORDER" "$SERVER_URL/api/dataverseFeaturedItems/$ID"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X PUT -F "file=@image.png" -F "content=Content for featured item." -F "displayOrder=1" "https://demo.dataverse.org/api/dataverseFeaturedItems/1"
+
+``content`` and ``displayOrder`` must always be provided; otherwise, an error will occur. Use the ``file`` parameter to set a new image for the featured item. To keep the existing image, omit ``file`` and send ``keepFile=true``. To remove the image, omit the file parameter.
+
+Updating the featured item keeping the existing image:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X PUT -F "keepFile=true" -F "content=Content for featured item." -F "displayOrder=1" "https://demo.dataverse.org/api/dataverseFeaturedItems/1"
+
+Updating the featured item removing the existing image:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X PUT -F "content=Content for featured item." -F "displayOrder=1" "https://demo.dataverse.org/api/dataverseFeaturedItems/1"
+
+Delete a Collection Featured Item
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Deletes a featured item given its ``id``:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=1
+
+  curl -H "X-Dataverse-key:$API_TOKEN" -X DELETE "$SERVER_URL/api/dataverseFeaturedItems/$ID"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X DELETE "https://demo.dataverse.org/api/dataverseFeaturedItems/1"
+
+Get a Collection Featured Item Image
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Returns the image of a featured item if one is assigned, given the featured item ``id``:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=1
+
+  curl -H "X-Dataverse-key:$API_TOKEN" -X GET "$SERVER_URL/api/access/dataverseFeaturedItemImage/{ID}"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X GET "https://demo.dataverse.org/api/access/dataverseFeaturedItemImage/1"
 
 Datasets
 --------
diff --git a/src/main/java/edu/harvard/iq/dataverse/Dataverse.java b/src/main/java/edu/harvard/iq/dataverse/Dataverse.java
index 9c51e15503e..9bb8992e789 100644
--- a/src/main/java/edu/harvard/iq/dataverse/Dataverse.java
+++ b/src/main/java/edu/harvard/iq/dataverse/Dataverse.java
@@ -1,5 +1,6 @@
 package edu.harvard.iq.dataverse;
 
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
 import edu.harvard.iq.dataverse.harvest.client.HarvestingClient;
 import edu.harvard.iq.dataverse.authorization.DataverseRole;
 import edu.harvard.iq.dataverse.search.savedsearch.SavedSearch;
@@ -352,6 +353,17 @@ public void setMetadataBlockFacets(List<DataverseMetadataBlockFacet> metadataBlo
         this.metadataBlockFacets = metadataBlockFacets;
     }
 
+    @OneToMany(mappedBy = "dataverse")
+    private List<DataverseFeaturedItem> dataverseFeaturedItems = new ArrayList<>();
+
+    public List<DataverseFeaturedItem> getDataverseFeaturedItems() {
+        return this.dataverseFeaturedItems;
+    }
+
+    public void setDataverseFeaturedItems(List<DataverseFeaturedItem> dataverseFeaturedItems) {
+        this.dataverseFeaturedItems = dataverseFeaturedItems;
+    }
+
     public List<Guestbook> getParentGuestbooks() {
         List<Guestbook> retList = new ArrayList<>();
         Dataverse testDV = this;
diff --git a/src/main/java/edu/harvard/iq/dataverse/EjbDataverseEngine.java b/src/main/java/edu/harvard/iq/dataverse/EjbDataverseEngine.java
index 0561fed8a97..0f211dc6713 100644
--- a/src/main/java/edu/harvard/iq/dataverse/EjbDataverseEngine.java
+++ b/src/main/java/edu/harvard/iq/dataverse/EjbDataverseEngine.java
@@ -4,6 +4,7 @@
 import edu.harvard.iq.dataverse.actionlogging.ActionLogServiceBean;
 import edu.harvard.iq.dataverse.authorization.AuthenticationServiceBean;
 import edu.harvard.iq.dataverse.authorization.providers.builtin.BuiltinUserServiceBean;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
 import edu.harvard.iq.dataverse.util.cache.CacheFactoryBean;
 import edu.harvard.iq.dataverse.engine.DataverseEngine;
 import edu.harvard.iq.dataverse.authorization.Permission;
@@ -184,7 +185,10 @@ public class EjbDataverseEngine {
     ConfirmEmailServiceBean confirmEmailService;
     
     @EJB
-    StorageUseServiceBean storageUseService; 
+    StorageUseServiceBean storageUseService;
+
+    @EJB
+    DataverseFeaturedItemServiceBean dataverseFeaturedItemServiceBean;
     
     @EJB
     EjbDataverseEngineInner innerEngine;
@@ -522,6 +526,11 @@ public DatasetFieldServiceBean dsField() {
                     return dsField;
                 }
 
+                @Override
+                public DataverseFeaturedItemServiceBean dataverseFeaturedItems() {
+                    return dataverseFeaturedItemServiceBean;
+                }
+
                 @Override
                 public StorageUseServiceBean storageUse() {
                     return storageUseService;
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java b/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
index 8a88ff042ab..6d54f3b6971 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
@@ -645,6 +645,8 @@ protected <T> T execCommand( Command<T> cmd ) throws WrappedResponse {
             }
         } catch (InvalidFieldsCommandException ex) {
             throw new WrappedResponse(ex, badRequest(ex.getMessage(), ex.getFieldErrors()));
+        } catch (InvalidCommandArgumentsException ex) {
+            throw new WrappedResponse(ex, error(Status.BAD_REQUEST, ex.getMessage()));
         } catch (CommandException ex) {
             Logger.getLogger(AbstractApiBean.class.getName()).log(Level.SEVERE, "Error while executing command " + cmd, ex);
             throw new WrappedResponse(ex, error(Status.INTERNAL_SERVER_ERROR, ex.getMessage()));
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Access.java b/src/main/java/edu/harvard/iq/dataverse/api/Access.java
index 16ac884180b..2a27c89eaaa 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Access.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Access.java
@@ -6,32 +6,7 @@
 
 package edu.harvard.iq.dataverse.api;
 
-import edu.harvard.iq.dataverse.AuxiliaryFile;
-import edu.harvard.iq.dataverse.AuxiliaryFileServiceBean;
-import edu.harvard.iq.dataverse.DataCitation;
-import edu.harvard.iq.dataverse.DataFile;
-import edu.harvard.iq.dataverse.FileAccessRequest;
-import edu.harvard.iq.dataverse.FileMetadata;
-import edu.harvard.iq.dataverse.DataFileServiceBean;
-import edu.harvard.iq.dataverse.Dataset;
-import edu.harvard.iq.dataverse.DatasetVersion;
-import edu.harvard.iq.dataverse.DatasetVersionServiceBean;
-import edu.harvard.iq.dataverse.DatasetServiceBean;
-import edu.harvard.iq.dataverse.Dataverse;
-import edu.harvard.iq.dataverse.DataverseRequestServiceBean;
-import edu.harvard.iq.dataverse.DataverseRoleServiceBean;
-import edu.harvard.iq.dataverse.DataverseServiceBean;
-import edu.harvard.iq.dataverse.DataverseSession;
-import edu.harvard.iq.dataverse.DataverseTheme;
-import edu.harvard.iq.dataverse.FileDownloadServiceBean;
-import edu.harvard.iq.dataverse.GuestbookResponse;
-import edu.harvard.iq.dataverse.GuestbookResponseServiceBean;
-import edu.harvard.iq.dataverse.PermissionServiceBean;
-import edu.harvard.iq.dataverse.PermissionsWrapper;
-import edu.harvard.iq.dataverse.RoleAssignment;
-import edu.harvard.iq.dataverse.UserNotification;
-import edu.harvard.iq.dataverse.UserNotificationServiceBean;
-import edu.harvard.iq.dataverse.ThemeWidgetFragment;
+import edu.harvard.iq.dataverse.*;
 
 import static edu.harvard.iq.dataverse.api.Datasets.handleVersion;
 
@@ -52,18 +27,12 @@
 import edu.harvard.iq.dataverse.dataaccess.ImageThumbConverter;
 import edu.harvard.iq.dataverse.datavariable.DataVariable;
 import edu.harvard.iq.dataverse.datavariable.VariableServiceBean;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
 import edu.harvard.iq.dataverse.engine.command.Command;
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
 import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
-import edu.harvard.iq.dataverse.engine.command.impl.AssignRoleCommand;
-import edu.harvard.iq.dataverse.engine.command.impl.GetDatasetCommand;
-import edu.harvard.iq.dataverse.engine.command.impl.GetDraftDatasetVersionCommand;
-import edu.harvard.iq.dataverse.engine.command.impl.GetLatestAccessibleDatasetVersionCommand;
-import edu.harvard.iq.dataverse.engine.command.impl.GetLatestPublishedDatasetVersionCommand;
-import edu.harvard.iq.dataverse.engine.command.impl.GetSpecificPublishedDatasetVersionCommand;
-import edu.harvard.iq.dataverse.engine.command.impl.RequestAccessCommand;
-import edu.harvard.iq.dataverse.engine.command.impl.RevokeRoleCommand;
-import edu.harvard.iq.dataverse.engine.command.impl.UpdateDatasetVersionCommand;
+import edu.harvard.iq.dataverse.engine.command.impl.*;
 import edu.harvard.iq.dataverse.export.DDIExportServiceBean;
 import edu.harvard.iq.dataverse.makedatacount.MakeDataCountLoggingServiceBean;
 import edu.harvard.iq.dataverse.makedatacount.MakeDataCountLoggingServiceBean.MakeDataCountEntry;
@@ -88,7 +57,6 @@
 import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
-import java.util.Properties;
 import java.util.logging.Level;
 import jakarta.inject.Inject;
 import jakarta.json.Json;
@@ -133,7 +101,6 @@
 
 import org.eclipse.microprofile.openapi.annotations.Operation;
 import org.eclipse.microprofile.openapi.annotations.media.Content;
-import org.eclipse.microprofile.openapi.annotations.media.Schema;
 import org.eclipse.microprofile.openapi.annotations.parameters.RequestBody;
 import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
 import org.eclipse.microprofile.openapi.annotations.responses.APIResponses;
@@ -199,6 +166,8 @@ public class Access extends AbstractApiBean {
     PermissionsWrapper permissionsWrapper;
     @Inject
     MakeDataCountLoggingServiceBean mdcLogService;
+    @Inject
+    DataverseFeaturedItemServiceBean dataverseFeaturedItemServiceBean;
     
     //@EJB
     
@@ -2015,4 +1984,24 @@ private URI handleCustomZipDownload(User user, String customZipServiceUrl, Strin
         }
         return redirectUri;
     }
+
+    @GET
+    @AuthRequired
+    @Produces({"image/png"})
+    @Path("dataverseFeaturedItemImage/{itemId}")
+    public InputStream getDataverseFeatureItemImage(@Context ContainerRequestContext crc, @PathParam("itemId") Long itemId) {
+        DataverseFeaturedItem dataverseFeaturedItem;
+        try {
+            dataverseFeaturedItem = execCommand(new GetDataverseFeaturedItemCommand(createDataverseRequest(getRequestUser(crc)), dataverseFeaturedItemServiceBean.findById(itemId)));
+        } catch (WrappedResponse wr) {
+            logger.warning("Cannot locate a dataverse featured item with id " + itemId);
+            return null;
+        }
+        try {
+            return dataverseFeaturedItemServiceBean.getImageFileAsInputStream(dataverseFeaturedItem);
+        } catch (IOException e) {
+            logger.warning("Error while obtaining the input stream for the image file associated with the dataverse featured item with id " + itemId);
+            return null;
+        }
+    }
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/DataverseFeaturedItems.java b/src/main/java/edu/harvard/iq/dataverse/api/DataverseFeaturedItems.java
new file mode 100644
index 00000000000..a77ea000415
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/api/DataverseFeaturedItems.java
@@ -0,0 +1,69 @@
+package edu.harvard.iq.dataverse.api;
+
+import edu.harvard.iq.dataverse.api.auth.AuthRequired;
+import edu.harvard.iq.dataverse.api.dto.UpdatedDataverseFeaturedItemDTO;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
+import edu.harvard.iq.dataverse.engine.command.impl.*;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import jakarta.ejb.Stateless;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.*;
+import jakarta.ws.rs.container.ContainerRequestContext;
+import jakarta.ws.rs.core.Context;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
+import org.glassfish.jersey.media.multipart.FormDataParam;
+
+import java.io.InputStream;
+import java.text.MessageFormat;
+
+import static edu.harvard.iq.dataverse.util.json.JsonPrinter.json;
+
+@Stateless
+@Path("dataverseFeaturedItems")
+public class DataverseFeaturedItems extends AbstractApiBean {
+
+    @Inject
+    DataverseFeaturedItemServiceBean dataverseFeaturedItemServiceBean;
+
+    @DELETE
+    @AuthRequired
+    @Path("{id}")
+    public Response deleteFeaturedItem(@Context ContainerRequestContext crc, @PathParam("id") Long id) {
+        try {
+            DataverseFeaturedItem dataverseFeaturedItem = dataverseFeaturedItemServiceBean.findById(id);
+            if (dataverseFeaturedItem == null) {
+                throw new WrappedResponse(error(Response.Status.NOT_FOUND, MessageFormat.format(BundleUtil.getStringFromBundle("dataverseFeaturedItems.errors.notFound"), id)));
+            }
+            execCommand(new DeleteDataverseFeaturedItemCommand(createDataverseRequest(getRequestUser(crc)), dataverseFeaturedItem));
+            return ok(MessageFormat.format(BundleUtil.getStringFromBundle("dataverseFeaturedItems.delete.successful"), id));
+        } catch (WrappedResponse e) {
+            return e.getResponse();
+        }
+    }
+
+    @PUT
+    @AuthRequired
+    @Consumes(MediaType.MULTIPART_FORM_DATA)
+    @Path("{id}")
+    public Response updateFeaturedItem(@Context ContainerRequestContext crc,
+                                       @PathParam("id") Long id,
+                                       @FormDataParam("content") String content,
+                                       @FormDataParam("displayOrder") int displayOrder,
+                                       @FormDataParam("keepFile") boolean keepFile,
+                                       @FormDataParam("file") InputStream imageFileInputStream,
+                                       @FormDataParam("file") FormDataContentDisposition contentDispositionHeader) {
+        try {
+            DataverseFeaturedItem dataverseFeaturedItem = dataverseFeaturedItemServiceBean.findById(id);
+            if (dataverseFeaturedItem == null) {
+                throw new WrappedResponse(error(Response.Status.NOT_FOUND, MessageFormat.format(BundleUtil.getStringFromBundle("dataverseFeaturedItems.errors.notFound"), id)));
+            }
+            UpdatedDataverseFeaturedItemDTO updatedDataverseFeaturedItemDTO = UpdatedDataverseFeaturedItemDTO.fromFormData(content, displayOrder, keepFile, imageFileInputStream, contentDispositionHeader);
+            return ok(json(execCommand(new UpdateDataverseFeaturedItemCommand(createDataverseRequest(getRequestUser(crc)), dataverseFeaturedItem, updatedDataverseFeaturedItemDTO))));
+        } catch (WrappedResponse e) {
+            return e.getResponse();
+        }
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
index f406f6078ef..bbd9476b9e8 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -1,6 +1,7 @@
 package edu.harvard.iq.dataverse.api;
 
 import com.google.common.collect.Lists;
+import com.google.api.client.util.ArrayMap;
 import edu.harvard.iq.dataverse.*;
 import edu.harvard.iq.dataverse.api.auth.AuthRequired;
 import edu.harvard.iq.dataverse.api.datadeposit.SwordServiceBean;
@@ -17,6 +18,8 @@
 import edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser;
 import edu.harvard.iq.dataverse.authorization.users.User;
 import edu.harvard.iq.dataverse.dataverse.DataverseUtil;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
 import edu.harvard.iq.dataverse.engine.command.impl.*;
 import edu.harvard.iq.dataverse.pidproviders.PidProvider;
@@ -34,7 +37,7 @@
 import edu.harvard.iq.dataverse.util.json.JsonPrinter;
 import edu.harvard.iq.dataverse.util.json.JsonUtil;
 
-import java.io.StringReader;
+import java.io.*;
 import java.util.*;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -60,8 +63,6 @@
 import jakarta.ws.rs.core.Response;
 import jakarta.ws.rs.core.Response.Status;
 
-import java.io.IOException;
-import java.io.OutputStream;
 import java.text.MessageFormat;
 import java.text.SimpleDateFormat;
 import java.util.stream.Collectors;
@@ -69,6 +70,10 @@
 import jakarta.ws.rs.WebApplicationException;
 import jakarta.ws.rs.core.Context;
 import jakarta.ws.rs.core.StreamingOutput;
+import org.glassfish.jersey.media.multipart.FormDataBodyPart;
+import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
+import org.glassfish.jersey.media.multipart.FormDataParam;
+
 import javax.xml.stream.XMLStreamException;
 
 /**
@@ -112,7 +117,10 @@ public class Dataverses extends AbstractApiBean {
 
     @EJB
     PermissionServiceBean permissionService;
-    
+
+    @EJB
+    DataverseFeaturedItemServiceBean dataverseFeaturedItemServiceBean;
+
     @POST
     @AuthRequired
     public Response addRoot(@Context ContainerRequestContext crc, String body) {
@@ -1768,4 +1776,131 @@ public Response getUserPermissionsOnDataverse(@Context ContainerRequestContext c
         jsonObjectBuilder.add("canDeleteDataverse", permissionService.userOn(requestUser, dataverse).has(Permission.DeleteDataverse));
         return ok(jsonObjectBuilder);
     }
+
+    @POST
+    @AuthRequired
+    @Consumes(MediaType.MULTIPART_FORM_DATA)
+    @Path("{identifier}/featuredItems")
+    public Response createFeaturedItem(@Context ContainerRequestContext crc,
+                                       @PathParam("identifier") String dvIdtf,
+                                       @FormDataParam("content") String content,
+                                       @FormDataParam("displayOrder") int displayOrder,
+                                       @FormDataParam("file") InputStream imageFileInputStream,
+                                       @FormDataParam("file") FormDataContentDisposition contentDispositionHeader) {
+        Dataverse dataverse;
+        try {
+            dataverse = findDataverseOrDie(dvIdtf);
+        } catch (WrappedResponse wr) {
+            return wr.getResponse();
+        }
+        NewDataverseFeaturedItemDTO newDataverseFeaturedItemDTO = NewDataverseFeaturedItemDTO.fromFormData(content, displayOrder, imageFileInputStream, contentDispositionHeader);
+        try {
+            DataverseFeaturedItem dataverseFeaturedItem = execCommand(new CreateDataverseFeaturedItemCommand(
+                    createDataverseRequest(getRequestUser(crc)),
+                    dataverse,
+                    newDataverseFeaturedItemDTO
+            ));
+            return ok(json(dataverseFeaturedItem));
+        } catch (WrappedResponse e) {
+            return e.getResponse();
+        }
+    }
+
+    @GET
+    @AuthRequired
+    @Path("{identifier}/featuredItems")
+    public Response listFeaturedItems(@Context ContainerRequestContext crc, @PathParam("identifier") String dvIdtf) {
+        try {
+            Dataverse dataverse = findDataverseOrDie(dvIdtf);
+            List<DataverseFeaturedItem> featuredItems = execCommand(new ListDataverseFeaturedItemsCommand(createDataverseRequest(getRequestUser(crc)), dataverse));
+            return ok(jsonDataverseFeaturedItems(featuredItems));
+        } catch (WrappedResponse e) {
+            return e.getResponse();
+        }
+    }
+
+    @PUT
+    @AuthRequired
+    @Consumes(MediaType.MULTIPART_FORM_DATA)
+    @Path("{dataverseId}/featuredItems")
+    public Response updateFeaturedItems(
+            @Context ContainerRequestContext crc,
+            @PathParam("dataverseId") String dvIdtf,
+            @FormDataParam("id") List<Long> ids,
+            @FormDataParam("content") List<String> contents,
+            @FormDataParam("displayOrder") List<Integer> displayOrders,
+            @FormDataParam("keepFile") List<Boolean> keepFiles,
+            @FormDataParam("fileName") List<String> fileNames,
+            @FormDataParam("file") List<FormDataBodyPart> files) {
+        try {
+            if (ids == null || contents == null || displayOrders == null || keepFiles == null || fileNames == null) {
+                throw new WrappedResponse(error(Response.Status.BAD_REQUEST,
+                        BundleUtil.getStringFromBundle("dataverse.update.featuredItems.error.missingInputParams")));
+            }
+
+            int size = ids.size();
+            if (contents.size() != size || displayOrders.size() != size || keepFiles.size() != size || fileNames.size() != size) {
+                throw new WrappedResponse(error(Response.Status.BAD_REQUEST,
+                        BundleUtil.getStringFromBundle("dataverse.update.featuredItems.error.inputListsSizeMismatch")));
+            }
+
+            Dataverse dataverse = findDataverseOrDie(dvIdtf);
+            List<NewDataverseFeaturedItemDTO> newItems = new ArrayList<>();
+            Map<DataverseFeaturedItem, UpdatedDataverseFeaturedItemDTO> itemsToUpdate = new HashMap<>();
+
+            for (int i = 0; i < contents.size(); i++) {
+                String fileName = fileNames.get(i);
+                InputStream fileInputStream = null;
+                FormDataContentDisposition contentDisposition = null;
+
+                if (files != null) {
+                    Optional<FormDataBodyPart> matchingFile = files.stream()
+                            .filter(file -> file.getFormDataContentDisposition().getFileName().equals(fileName))
+                            .findFirst();
+
+                    if (matchingFile.isPresent()) {
+                        fileInputStream = matchingFile.get().getValueAs(InputStream.class);
+                        contentDisposition = matchingFile.get().getFormDataContentDisposition();
+                    }
+                }
+
+                if (ids.get(i) == 0) {
+                    newItems.add(NewDataverseFeaturedItemDTO.fromFormData(
+                            contents.get(i), displayOrders.get(i), fileInputStream, contentDisposition));
+                } else {
+                    DataverseFeaturedItem existingItem = dataverseFeaturedItemServiceBean.findById(ids.get(i));
+                    if (existingItem == null) {
+                        throw new WrappedResponse(error(Response.Status.NOT_FOUND,
+                                MessageFormat.format(BundleUtil.getStringFromBundle("dataverseFeaturedItems.errors.notFound"), ids.get(i))));
+                    }
+                    itemsToUpdate.put(existingItem, UpdatedDataverseFeaturedItemDTO.fromFormData(
+                            contents.get(i), displayOrders.get(i), keepFiles.get(i), fileInputStream, contentDisposition));
+                }
+            }
+
+            List<DataverseFeaturedItem> featuredItems = execCommand(new UpdateDataverseFeaturedItemsCommand(
+                    createDataverseRequest(getRequestUser(crc)),
+                    dataverse,
+                    newItems,
+                    itemsToUpdate
+            ));
+
+            return ok(jsonDataverseFeaturedItems(featuredItems));
+        } catch (WrappedResponse wr) {
+            return wr.getResponse();
+        }
+    }
+
+    @DELETE
+    @AuthRequired
+    @Path("{identifier}/featuredItems")
+    public Response deleteFeaturedItems(@Context ContainerRequestContext crc, @PathParam("identifier") String dvIdtf) {
+        try {
+            Dataverse dataverse = findDataverseOrDie(dvIdtf);
+            execCommand(new UpdateDataverseFeaturedItemsCommand(createDataverseRequest(getRequestUser(crc)), dataverse, new ArrayList<>(), new ArrayMap<>()));
+            return ok(BundleUtil.getStringFromBundle("dataverse.delete.featuredItems.success"));
+        } catch (WrappedResponse e) {
+            return e.getResponse();
+        }
+    }
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/dto/NewDataverseFeaturedItemDTO.java b/src/main/java/edu/harvard/iq/dataverse/api/dto/NewDataverseFeaturedItemDTO.java
new file mode 100644
index 00000000000..47003761abc
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/api/dto/NewDataverseFeaturedItemDTO.java
@@ -0,0 +1,61 @@
+package edu.harvard.iq.dataverse.api.dto;
+
+import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
+
+import java.io.InputStream;
+
+public class NewDataverseFeaturedItemDTO {
+    private String content;
+    private int displayOrder;
+    private InputStream imageFileInputStream;
+    private String imageFileName;
+
+    public static NewDataverseFeaturedItemDTO fromFormData(String content,
+                                                           int displayOrder,
+                                                           InputStream imageFileInputStream,
+                                                           FormDataContentDisposition contentDispositionHeader) {
+        NewDataverseFeaturedItemDTO newDataverseFeaturedItemDTO = new NewDataverseFeaturedItemDTO();
+
+        newDataverseFeaturedItemDTO.content = content;
+        newDataverseFeaturedItemDTO.displayOrder = displayOrder;
+
+        if (imageFileInputStream != null) {
+            newDataverseFeaturedItemDTO.imageFileInputStream = imageFileInputStream;
+            newDataverseFeaturedItemDTO.imageFileName = contentDispositionHeader.getFileName();
+        }
+
+        return newDataverseFeaturedItemDTO;
+    }
+
+    public void setContent(String content) {
+        this.content = content;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public void setDisplayOrder(int displayOrder) {
+        this.displayOrder = displayOrder;
+    }
+
+    public int getDisplayOrder() {
+        return displayOrder;
+    }
+
+    public void setImageFileInputStream(InputStream imageFileInputStream) {
+        this.imageFileInputStream = imageFileInputStream;
+    }
+
+    public InputStream getImageFileInputStream() {
+        return imageFileInputStream;
+    }
+
+    public void setImageFileName(String imageFileName) {
+        this.imageFileName = imageFileName;
+    }
+
+    public String getImageFileName() {
+        return imageFileName;
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/dto/UpdatedDataverseFeaturedItemDTO.java b/src/main/java/edu/harvard/iq/dataverse/api/dto/UpdatedDataverseFeaturedItemDTO.java
new file mode 100644
index 00000000000..43d1afc31e2
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/api/dto/UpdatedDataverseFeaturedItemDTO.java
@@ -0,0 +1,72 @@
+package edu.harvard.iq.dataverse.api.dto;
+
+import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
+
+import java.io.InputStream;
+
+public class UpdatedDataverseFeaturedItemDTO {
+    private String content;
+    private int displayOrder;
+    private boolean keepFile;
+    private InputStream imageFileInputStream;
+    private String imageFileName;
+
+    public static UpdatedDataverseFeaturedItemDTO fromFormData(String content,
+                                                               int displayOrder,
+                                                               boolean keepFile,
+                                                               InputStream imageFileInputStream,
+                                                               FormDataContentDisposition contentDispositionHeader) {
+        UpdatedDataverseFeaturedItemDTO updatedDataverseFeaturedItemDTO = new UpdatedDataverseFeaturedItemDTO();
+
+        updatedDataverseFeaturedItemDTO.content = content;
+        updatedDataverseFeaturedItemDTO.displayOrder = displayOrder;
+        updatedDataverseFeaturedItemDTO.keepFile = keepFile;
+
+        if (imageFileInputStream != null) {
+            updatedDataverseFeaturedItemDTO.imageFileInputStream = imageFileInputStream;
+            updatedDataverseFeaturedItemDTO.imageFileName = contentDispositionHeader.getFileName();
+        }
+
+        return updatedDataverseFeaturedItemDTO;
+    }
+
+    public void setContent(String content) {
+        this.content = content;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public void setDisplayOrder(int displayOrder) {
+        this.displayOrder = displayOrder;
+    }
+
+    public int getDisplayOrder() {
+        return displayOrder;
+    }
+
+    public void setKeepFile(boolean keepFile) {
+        this.keepFile = keepFile;
+    }
+
+    public boolean isKeepFile() {
+        return keepFile;
+    }
+
+    public void setImageFileInputStream(InputStream imageFileInputStream) {
+        this.imageFileInputStream = imageFileInputStream;
+    }
+
+    public InputStream getImageFileInputStream() {
+        return imageFileInputStream;
+    }
+
+    public void setImageFileName(String imageFileName) {
+        this.imageFileName = imageFileName;
+    }
+
+    public String getImageFileName() {
+        return imageFileName;
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/dataverse/featured/DataverseFeaturedItem.java b/src/main/java/edu/harvard/iq/dataverse/dataverse/featured/DataverseFeaturedItem.java
new file mode 100644
index 00000000000..53d09516789
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/dataverse/featured/DataverseFeaturedItem.java
@@ -0,0 +1,88 @@
+package edu.harvard.iq.dataverse.dataverse.featured;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.util.SystemConfig;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.Size;
+
+@NamedQueries({
+        @NamedQuery(name = "DataverseFeaturedItem.deleteById",
+                query = "DELETE FROM DataverseFeaturedItem item WHERE item.id=:id"),
+        @NamedQuery(name = "DataverseFeaturedItem.findByDataverseOrderedByDisplayOrder",
+                query = "SELECT item FROM DataverseFeaturedItem item WHERE item.dataverse = :dataverse ORDER BY item.displayOrder ASC")
+})
+@Entity
+@Table(indexes = @Index(columnList = "displayOrder"))
+public class DataverseFeaturedItem {
+
+    public static final int MAX_FEATURED_ITEM_CONTENT_SIZE = 15000;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne
+    @JoinColumn(nullable = false)
+    private Dataverse dataverse;
+
+    @NotBlank
+    @Size(max = MAX_FEATURED_ITEM_CONTENT_SIZE)
+    @Lob
+    @Column(columnDefinition = "TEXT", nullable = false)
+    private String content;
+
+    @Min(0)
+    @Column(nullable = false)
+    private int displayOrder;
+
+    private String imageFileName;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Dataverse getDataverse() {
+        return dataverse;
+    }
+
+    public void setDataverse(Dataverse dataverse) {
+        this.dataverse = dataverse;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public void setContent(String content) {
+        this.content = content;
+    }
+
+    public int getDisplayOrder() {
+        return displayOrder;
+    }
+
+    public void setDisplayOrder(int displayOrder) {
+        this.displayOrder = displayOrder;
+    }
+
+    public String getImageFileName() {
+        return imageFileName;
+    }
+
+    public void setImageFileName(String imageFileName) {
+        this.imageFileName = imageFileName;
+    }
+
+    public String getImageFileUrl() {
+        if (id != null && imageFileName != null) {
+            return SystemConfig.getDataverseSiteUrlStatic() + "/api/access/dataverseFeaturedItemImage/" + id;
+        }
+        return null;
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/dataverse/featured/DataverseFeaturedItemServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/dataverse/featured/DataverseFeaturedItemServiceBean.java
new file mode 100644
index 00000000000..56cdaf5692e
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/dataverse/featured/DataverseFeaturedItemServiceBean.java
@@ -0,0 +1,100 @@
+package edu.harvard.iq.dataverse.dataverse.featured;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.settings.JvmSettings;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import edu.harvard.iq.dataverse.util.FileUtil;
+import jakarta.ejb.Stateless;
+import jakarta.inject.Named;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Serializable;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.List;
+
+@Stateless
+@Named
+public class DataverseFeaturedItemServiceBean implements Serializable {
+
+    public static class InvalidImageFileException extends Exception {
+        public InvalidImageFileException(String message) {
+            super(message);
+        }
+    }
+
+    @PersistenceContext(unitName = "VDCNet-ejbPU")
+    private EntityManager em;
+
+    public DataverseFeaturedItem findById(Long id) {
+        return em.find(DataverseFeaturedItem.class, id);
+    }
+
+    public DataverseFeaturedItem save(DataverseFeaturedItem dataverseFeaturedItem) {
+        if (dataverseFeaturedItem.getId() == null) {
+            em.persist(dataverseFeaturedItem);
+            em.flush();
+        } else {
+            dataverseFeaturedItem = em.merge(dataverseFeaturedItem);
+        }
+        return dataverseFeaturedItem;
+    }
+
+    public void delete(Long id) {
+        em.createNamedQuery("DataverseFeaturedItem.deleteById", DataverseFeaturedItem.class)
+                .setParameter("id", id)
+                .executeUpdate();
+    }
+
+    public List<DataverseFeaturedItem> findAllByDataverseOrdered(Dataverse dataverse) {
+        return em
+                .createNamedQuery("DataverseFeaturedItem.findByDataverseOrderedByDisplayOrder", DataverseFeaturedItem.class)
+                .setParameter("dataverse", dataverse)
+                .getResultList();
+    }
+
+    public InputStream getImageFileAsInputStream(DataverseFeaturedItem dataverseFeaturedItem) throws IOException {
+        Path imagePath = Path.of(JvmSettings.DOCROOT_DIRECTORY.lookup(),
+                JvmSettings.FEATURED_ITEMS_IMAGE_UPLOADS_DIRECTORY.lookup(),
+                dataverseFeaturedItem.getDataverse().getId().toString(),
+                dataverseFeaturedItem.getImageFileName());
+        return Files.newInputStream(imagePath);
+    }
+
+    public void saveDataverseFeaturedItemImageFile(InputStream inputStream, String imageFileName, Long dataverseId) throws IOException, InvalidImageFileException {
+        File tempFile = FileUtil.inputStreamToFile(inputStream);
+        validateImageFile(tempFile);
+
+        Path imageDir = FileUtil.createDirStructure(
+                JvmSettings.DOCROOT_DIRECTORY.lookup(),
+                JvmSettings.FEATURED_ITEMS_IMAGE_UPLOADS_DIRECTORY.lookup(),
+                dataverseId.toString()
+        );
+        File uploadedFile = new File(imageDir.toFile(), imageFileName);
+
+        if (!uploadedFile.exists()) {
+            uploadedFile.createNewFile();
+        }
+
+        Files.copy(tempFile.toPath(), uploadedFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
+    }
+
+    private void validateImageFile(File file) throws IOException, InvalidImageFileException {
+        if (!FileUtil.isFileOfImageType(file)) {
+            throw new InvalidImageFileException(
+                    BundleUtil.getStringFromBundle("dataverse.create.featuredItem.error.invalidFileType")
+            );
+        }
+        Integer maxAllowedSize = JvmSettings.FEATURED_ITEMS_IMAGE_MAXSIZE.lookup(Integer.class);
+        if (file.length() > maxAllowedSize) {
+            throw new InvalidImageFileException(
+                    BundleUtil.getStringFromBundle("dataverse.create.featuredItem.error.fileSizeExceedsLimit", List.of(maxAllowedSize.toString()))
+            );
+        }
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/CommandContext.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/CommandContext.java
index 282cbb88988..42f2616cd80 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/CommandContext.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/CommandContext.java
@@ -1,28 +1,10 @@
 package edu.harvard.iq.dataverse.engine.command;
 
-import edu.harvard.iq.dataverse.DataFileServiceBean;
-import edu.harvard.iq.dataverse.DatasetFieldServiceBean;
-import edu.harvard.iq.dataverse.DatasetLinkingServiceBean;
-import edu.harvard.iq.dataverse.DatasetServiceBean;
-import edu.harvard.iq.dataverse.DatasetVersionServiceBean;
-import edu.harvard.iq.dataverse.DataverseFacetServiceBean;
-import edu.harvard.iq.dataverse.DataverseFieldTypeInputLevelServiceBean;
-import edu.harvard.iq.dataverse.DataverseLinkingServiceBean;
-import edu.harvard.iq.dataverse.DataverseRoleServiceBean;
-import edu.harvard.iq.dataverse.DataverseServiceBean;
+import edu.harvard.iq.dataverse.*;
 import edu.harvard.iq.dataverse.authorization.providers.builtin.BuiltinUserServiceBean;
-import edu.harvard.iq.dataverse.DvObjectServiceBean;
-import edu.harvard.iq.dataverse.FeaturedDataverseServiceBean;
-import edu.harvard.iq.dataverse.FileDownloadServiceBean;
-import edu.harvard.iq.dataverse.GuestbookResponseServiceBean;
-import edu.harvard.iq.dataverse.GuestbookServiceBean;
-import edu.harvard.iq.dataverse.MetadataBlockServiceBean;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
 import edu.harvard.iq.dataverse.search.IndexServiceBean;
-import edu.harvard.iq.dataverse.PermissionServiceBean;
-import edu.harvard.iq.dataverse.RoleAssigneeServiceBean;
 import edu.harvard.iq.dataverse.search.SearchServiceBean;
-import edu.harvard.iq.dataverse.TemplateServiceBean;
-import edu.harvard.iq.dataverse.UserNotificationServiceBean;
 import edu.harvard.iq.dataverse.actionlogging.ActionLogServiceBean;
 import edu.harvard.iq.dataverse.authorization.AuthenticationServiceBean;
 import edu.harvard.iq.dataverse.authorization.groups.GroupServiceBean;
@@ -152,4 +134,6 @@ public interface CommandContext {
     public void addCommand(Command command);
 
     public DatasetFieldServiceBean dsField();
+
+    public DataverseFeaturedItemServiceBean dataverseFeaturedItems();
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/exception/InvalidCommandArgumentsException.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/exception/InvalidCommandArgumentsException.java
new file mode 100644
index 00000000000..95c6f52b880
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/exception/InvalidCommandArgumentsException.java
@@ -0,0 +1,25 @@
+package edu.harvard.iq.dataverse.engine.command.exception;
+
+import edu.harvard.iq.dataverse.engine.command.Command;
+
+/**
+ * Exception thrown when a {@link Command} is executed with invalid or malformed arguments.
+ * <p>
+ * This exception typically indicates that the input parameters provided to the command
+ * do not meet the required criteria (e.g., missing fields, invalid formats, or other
+ * constraints).
+ * </p>
+ * <p>
+ * Example scenarios:
+ * <ul>
+ *   <li>A required argument is null or missing.</li>
+ *   <li>An argument is in an invalid format (e.g., a malformed email address).</li>
+ *   <li>Arguments violate business rules or constraints.</li>
+ * </ul>
+ */
+public class InvalidCommandArgumentsException extends CommandException {
+
+    public InvalidCommandArgumentsException(String message, Command aCommand) {
+        super(message, aCommand);
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/AbstractWriteDataverseFeaturedItemCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/AbstractWriteDataverseFeaturedItemCommand.java
new file mode 100644
index 00000000000..8c4a8281345
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/AbstractWriteDataverseFeaturedItemCommand.java
@@ -0,0 +1,77 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.*;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
+import edu.harvard.iq.dataverse.engine.command.AbstractCommand;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.RequiredPermissions;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import edu.harvard.iq.dataverse.util.MarkupChecker;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.text.MessageFormat;
+import java.util.List;
+
+/**
+ * An abstract base class for commands that perform write operations on {@link DataverseFeaturedItem}s.
+ */
+@RequiredPermissions({Permission.EditDataverse})
+abstract class AbstractWriteDataverseFeaturedItemCommand extends AbstractCommand<DataverseFeaturedItem> {
+
+    protected final Dataverse dataverse;
+
+    public AbstractWriteDataverseFeaturedItemCommand(DataverseRequest request, Dataverse affectedDataverse) {
+        super(request, affectedDataverse);
+        this.dataverse = affectedDataverse;
+    }
+
+    protected void validateAndSetContent(DataverseFeaturedItem featuredItem, String content) throws InvalidCommandArgumentsException {
+        if (content == null || content.trim().isEmpty()) {
+            throw new InvalidCommandArgumentsException(
+                    BundleUtil.getStringFromBundle("dataverse.create.featuredItem.error.contentShouldBeProvided"),
+                    this
+            );
+        }
+        content = MarkupChecker.sanitizeAdvancedHTML(content);
+        if (content.length() > DataverseFeaturedItem.MAX_FEATURED_ITEM_CONTENT_SIZE) {
+            throw new InvalidCommandArgumentsException(
+                    MessageFormat.format(
+                            BundleUtil.getStringFromBundle("dataverse.create.featuredItem.error.contentExceedsLengthLimit"),
+                            List.of(DataverseFeaturedItem.MAX_FEATURED_ITEM_CONTENT_SIZE)
+                    ),
+                    this
+            );
+        }
+        featuredItem.setContent(content);
+    }
+
+    protected void setFileImageIfAvailableOrNull(DataverseFeaturedItem featuredItem, String imageFileName, InputStream imageFileInputStream, CommandContext ctxt) throws CommandException {
+        if (imageFileName != null && imageFileInputStream != null) {
+            try {
+                ctxt.dataverseFeaturedItems().saveDataverseFeaturedItemImageFile(imageFileInputStream, imageFileName, dataverse.getId());
+            } catch (DataverseFeaturedItemServiceBean.InvalidImageFileException e) {
+                throw new InvalidCommandArgumentsException(
+                        e.getMessage(),
+                        this
+                );
+            } catch (IOException e) {
+                throw new CommandException(
+                        BundleUtil.getStringFromBundle(
+                                "dataverse.create.featuredItem.error.imageFileProcessing",
+                                List.of(e.getMessage())
+                        ),
+                        this
+                );
+            }
+            featuredItem.setImageFileName(imageFileName);
+        } else {
+            featuredItem.setImageFileName(null);
+        }
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDataverseFeaturedItemCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDataverseFeaturedItemCommand.java
new file mode 100644
index 00000000000..24732d05c8b
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDataverseFeaturedItemCommand.java
@@ -0,0 +1,42 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.api.dto.NewDataverseFeaturedItemDTO;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+
+/**
+ * Creates a featured item {@link DataverseFeaturedItem} for a {@link Dataverse}.
+ */
+public class CreateDataverseFeaturedItemCommand extends AbstractWriteDataverseFeaturedItemCommand {
+
+    private final NewDataverseFeaturedItemDTO newDataverseFeaturedItemDTO;
+
+    public CreateDataverseFeaturedItemCommand(DataverseRequest request,
+                                              Dataverse dataverse,
+                                              NewDataverseFeaturedItemDTO newDataverseFeaturedItemDTO) {
+        super(request, dataverse);
+        this.newDataverseFeaturedItemDTO = newDataverseFeaturedItemDTO;
+    }
+
+    @Override
+    public DataverseFeaturedItem execute(CommandContext ctxt) throws CommandException {
+        DataverseFeaturedItem dataverseFeaturedItem = new DataverseFeaturedItem();
+
+        validateAndSetContent(dataverseFeaturedItem, newDataverseFeaturedItemDTO.getContent());
+        dataverseFeaturedItem.setDisplayOrder(newDataverseFeaturedItemDTO.getDisplayOrder());
+
+        setFileImageIfAvailableOrNull(
+                dataverseFeaturedItem,
+                newDataverseFeaturedItemDTO.getImageFileName(),
+                newDataverseFeaturedItemDTO.getImageFileInputStream(),
+                ctxt
+        );
+
+        dataverseFeaturedItem.setDataverse(dataverse);
+
+        return ctxt.dataverseFeaturedItems().save(dataverseFeaturedItem);
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDataverseCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDataverseCommand.java
index c7c592f9458..84a0ab0f3f2 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDataverseCommand.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDataverseCommand.java
@@ -1,6 +1,7 @@
 package edu.harvard.iq.dataverse.engine.command.impl;
 
 import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
 import edu.harvard.iq.dataverse.DataverseFieldTypeInputLevel;
 import edu.harvard.iq.dataverse.authorization.DataverseRole;
 import edu.harvard.iq.dataverse.RoleAssignment;
@@ -78,6 +79,14 @@ protected void executeImpl(CommandContext ctxt) throws CommandException {
             ctxt.em().remove(merged);
         }
         doomed.setDataverseFieldTypeInputLevels(new ArrayList<>());
+
+        // Featured Items
+        for (DataverseFeaturedItem featuredItem : doomed.getDataverseFeaturedItems()) {
+            DataverseFeaturedItem merged = ctxt.em().merge(featuredItem);
+            ctxt.em().remove(merged);
+        }
+        doomed.setDataverseFeaturedItems(new ArrayList<>());
+
         // DATAVERSE
         Dataverse doomedAndMerged = ctxt.em().merge(doomed);
         ctxt.em().remove(doomedAndMerged);
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDataverseFeaturedItemCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDataverseFeaturedItemCommand.java
new file mode 100644
index 00000000000..215863a44da
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteDataverseFeaturedItemCommand.java
@@ -0,0 +1,26 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.engine.command.*;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+
+/**
+ * Deletes a particular featured item {@link DataverseFeaturedItem} of a {@link Dataverse}.
+ */
+@RequiredPermissions({Permission.EditDataverse})
+public class DeleteDataverseFeaturedItemCommand extends AbstractVoidCommand {
+
+    private final DataverseFeaturedItem doomed;
+
+    public DeleteDataverseFeaturedItemCommand(DataverseRequest request, DataverseFeaturedItem doomed) {
+        super(request, doomed.getDataverse());
+        this.doomed = doomed;
+    }
+
+    @Override
+    protected void executeImpl(CommandContext ctxt) throws CommandException {
+        ctxt.dataverseFeaturedItems().delete(doomed.getId());
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/GetDataverseFeaturedItemCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/GetDataverseFeaturedItemCommand.java
new file mode 100644
index 00000000000..c594887b6ed
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/GetDataverseFeaturedItemCommand.java
@@ -0,0 +1,37 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.engine.command.AbstractCommand;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Retrieves a particular featured item {@link DataverseFeaturedItem}.
+ */
+public class GetDataverseFeaturedItemCommand extends AbstractCommand<DataverseFeaturedItem> {
+
+    private final DataverseFeaturedItem dataverseFeaturedItem;
+
+    public GetDataverseFeaturedItemCommand(DataverseRequest request, DataverseFeaturedItem dataverseFeaturedItem) {
+        super(request, dataverseFeaturedItem.getDataverse());
+        this.dataverseFeaturedItem = dataverseFeaturedItem;
+    }
+
+    @Override
+    public DataverseFeaturedItem execute(CommandContext ctxt) throws CommandException {
+        return dataverseFeaturedItem;
+    }
+
+    @Override
+    public Map<String, Set<Permission>> getRequiredPermissions() {
+        return Collections.singletonMap("",
+                dataverseFeaturedItem.getDataverse().isReleased() ? Collections.emptySet()
+                        : Collections.singleton(Permission.ViewUnpublishedDataverse));
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseFeaturedItemsCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseFeaturedItemsCommand.java
new file mode 100644
index 00000000000..0d4051fc7d5
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseFeaturedItemsCommand.java
@@ -0,0 +1,36 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.engine.command.AbstractCommand;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+
+import java.util.*;
+
+/**
+ * Lists the featured items {@link DataverseFeaturedItem} of a {@link Dataverse}.
+ */
+public class ListDataverseFeaturedItemsCommand extends AbstractCommand<List<DataverseFeaturedItem>> {
+
+    private final Dataverse dataverse;
+
+    public ListDataverseFeaturedItemsCommand(DataverseRequest request, Dataverse dataverse) {
+        super(request, dataverse);
+        this.dataverse = dataverse;
+    }
+
+    @Override
+    public List<DataverseFeaturedItem> execute(CommandContext ctxt) throws CommandException {
+        return ctxt.dataverseFeaturedItems().findAllByDataverseOrdered(dataverse);
+    }
+
+    @Override
+    public Map<String, Set<Permission>> getRequiredPermissions() {
+        return Collections.singletonMap("",
+                dataverse.isReleased() ? Collections.emptySet()
+                        : Collections.singleton(Permission.ViewUnpublishedDataverse));
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDataverseFeaturedItemCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDataverseFeaturedItemCommand.java
new file mode 100644
index 00000000000..ed6fe825b03
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDataverseFeaturedItemCommand.java
@@ -0,0 +1,41 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.api.dto.UpdatedDataverseFeaturedItemDTO;
+import edu.harvard.iq.dataverse.engine.command.*;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+
+/**
+ * Updates a particular featured item {@link DataverseFeaturedItem} of a {@link Dataverse}.
+ */
+public class UpdateDataverseFeaturedItemCommand extends AbstractWriteDataverseFeaturedItemCommand {
+
+    private final DataverseFeaturedItem dataverseFeaturedItem;
+    private final UpdatedDataverseFeaturedItemDTO updatedDataverseFeaturedItemDTO;
+
+    public UpdateDataverseFeaturedItemCommand(DataverseRequest request,
+                                              DataverseFeaturedItem dataverseFeaturedItem,
+                                              UpdatedDataverseFeaturedItemDTO updatedDataverseFeaturedItemDTO) {
+        super(request, dataverseFeaturedItem.getDataverse());
+        this.dataverseFeaturedItem = dataverseFeaturedItem;
+        this.updatedDataverseFeaturedItemDTO = updatedDataverseFeaturedItemDTO;
+    }
+
+    @Override
+    public DataverseFeaturedItem execute(CommandContext ctxt) throws CommandException {
+        validateAndSetContent(dataverseFeaturedItem, updatedDataverseFeaturedItemDTO.getContent());
+        dataverseFeaturedItem.setDisplayOrder(updatedDataverseFeaturedItemDTO.getDisplayOrder());
+
+        if (!updatedDataverseFeaturedItemDTO.isKeepFile()) {
+            setFileImageIfAvailableOrNull(
+                    dataverseFeaturedItem,
+                    updatedDataverseFeaturedItemDTO.getImageFileName(),
+                    updatedDataverseFeaturedItemDTO.getImageFileInputStream(),
+                    ctxt
+            );
+        }
+
+        return ctxt.dataverseFeaturedItems().save(dataverseFeaturedItem);
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDataverseFeaturedItemsCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDataverseFeaturedItemsCommand.java
new file mode 100644
index 00000000000..0368efef6b0
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateDataverseFeaturedItemsCommand.java
@@ -0,0 +1,78 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.api.dto.NewDataverseFeaturedItemDTO;
+import edu.harvard.iq.dataverse.api.dto.UpdatedDataverseFeaturedItemDTO;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.engine.command.*;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Updates all featured items ({@link DataverseFeaturedItem}) for a specified {@link Dataverse}.
+ * <p>
+ * This command allows for the creation of multiple new featured items, updates to existing items with new parameters,
+ * or the deletion of existing items, all in a single command.
+ * </p>
+ **/
+@RequiredPermissions({Permission.EditDataverse})
+public class UpdateDataverseFeaturedItemsCommand extends AbstractCommand<List<DataverseFeaturedItem>> {
+
+    private final Dataverse dataverse;
+    private final List<NewDataverseFeaturedItemDTO> newDataverseFeaturedItemDTOs;
+    private final Map<DataverseFeaturedItem, UpdatedDataverseFeaturedItemDTO> dataverseFeaturedItemsToUpdate;
+
+    public UpdateDataverseFeaturedItemsCommand(DataverseRequest request, Dataverse dataverse, List<NewDataverseFeaturedItemDTO> newDataverseFeaturedItemDTOs, Map<DataverseFeaturedItem, UpdatedDataverseFeaturedItemDTO> dataverseFeaturedItemsToUpdate) {
+        super(request, dataverse);
+        this.dataverse = dataverse;
+        this.newDataverseFeaturedItemDTOs = newDataverseFeaturedItemDTOs;
+        this.dataverseFeaturedItemsToUpdate = dataverseFeaturedItemsToUpdate;
+    }
+
+    @Override
+    public List<DataverseFeaturedItem> execute(CommandContext ctxt) throws CommandException {
+        List<DataverseFeaturedItem> dataverseFeaturedItems = updateOrDeleteExistingFeaturedItems(ctxt);
+        dataverseFeaturedItems.addAll(createNewFeaturedItems(ctxt));
+        dataverseFeaturedItems.sort(Comparator.comparingInt(DataverseFeaturedItem::getDisplayOrder));
+        return dataverseFeaturedItems;
+    }
+
+    private List<DataverseFeaturedItem> updateOrDeleteExistingFeaturedItems(CommandContext ctxt) throws CommandException {
+        List<DataverseFeaturedItem> updatedFeaturedItems = new ArrayList<>();
+        List<DataverseFeaturedItem> featuredItemsToDelete = dataverse.getDataverseFeaturedItems();
+
+        for (Map.Entry<DataverseFeaturedItem, UpdatedDataverseFeaturedItemDTO> entry : dataverseFeaturedItemsToUpdate.entrySet()) {
+            DataverseFeaturedItem featuredItem = entry.getKey();
+            UpdatedDataverseFeaturedItemDTO updatedDTO = entry.getValue();
+
+            featuredItemsToDelete.stream()
+                    .filter(item -> item.getId().equals(featuredItem.getId()))
+                    .findFirst().ifPresent(featuredItemsToDelete::remove);
+
+            DataverseFeaturedItem updatedFeatureItem = ctxt.engine().submit(new UpdateDataverseFeaturedItemCommand(getRequest(), featuredItem, updatedDTO));
+            updatedFeaturedItems.add(updatedFeatureItem);
+        }
+
+        for (DataverseFeaturedItem featuredItem : featuredItemsToDelete) {
+            ctxt.engine().submit(new DeleteDataverseFeaturedItemCommand(getRequest(), featuredItem));
+        }
+
+        return updatedFeaturedItems;
+    }
+
+    private List<DataverseFeaturedItem> createNewFeaturedItems(CommandContext ctxt) throws CommandException {
+        List<DataverseFeaturedItem> createdFeaturedItems = new ArrayList<>();
+
+        for (NewDataverseFeaturedItemDTO dto : newDataverseFeaturedItemDTOs) {
+            DataverseFeaturedItem createdFeatureItem = ctxt.engine().submit(new CreateDataverseFeaturedItemCommand(getRequest(), dataverse, dto));
+            createdFeaturedItems.add(createdFeatureItem);
+        }
+
+        return createdFeaturedItems;
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/settings/JvmSettings.java b/src/main/java/edu/harvard/iq/dataverse/settings/JvmSettings.java
index d7eea970b8a..482c5ecbbb5 100644
--- a/src/main/java/edu/harvard/iq/dataverse/settings/JvmSettings.java
+++ b/src/main/java/edu/harvard/iq/dataverse/settings/JvmSettings.java
@@ -52,6 +52,9 @@ public enum JvmSettings {
     GUESTBOOK_AT_REQUEST(SCOPE_FILES, "guestbook-at-request"),
     GLOBUS_CACHE_MAXAGE(SCOPE_FILES, "globus-cache-maxage"),
     GLOBUS_TASK_MONITORING_SERVER(SCOPE_FILES, "globus-monitoring-server"),
+    SCOPE_FEATURED_ITEMS(SCOPE_FILES, "featured-items"),
+    FEATURED_ITEMS_IMAGE_MAXSIZE(SCOPE_FEATURED_ITEMS, "image-maxsize"),
+    FEATURED_ITEMS_IMAGE_UPLOADS_DIRECTORY(SCOPE_FEATURED_ITEMS, "image-uploads"),
 
     //STORAGE DRIVER SETTINGS
     SCOPE_DRIVER(SCOPE_FILES),
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/FileUtil.java b/src/main/java/edu/harvard/iq/dataverse/util/FileUtil.java
index 991682ec8e8..e134c64277c 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/FileUtil.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/FileUtil.java
@@ -103,6 +103,7 @@
 import java.util.Arrays;
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.StringUtils;
+import org.apache.tika.Tika;
 import ucar.nc2.NetcdfFile;
 import ucar.nc2.NetcdfFiles;
 
@@ -1828,4 +1829,16 @@ public static String getStorageDriver(DataFile dataFile) {
     public static String sanitizeFileName(String fileNameIn) {
         return fileNameIn == null ? null : fileNameIn.replace(' ', '_').replaceAll("[\\\\/:*?\"<>|,;]", "");
     }
+
+    public static Path createDirStructure(String rootDirectory, String... subdirectories) throws IOException {
+        Path path = Path.of(rootDirectory, subdirectories);
+        Files.createDirectories(path);
+        return path;
+    }
+
+    public static boolean isFileOfImageType(File file) throws IOException {
+        Tika tika = new Tika();
+        String mimeType = tika.detect(file);
+        return mimeType != null && mimeType.startsWith("image/");
+    }
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/MarkupChecker.java b/src/main/java/edu/harvard/iq/dataverse/util/MarkupChecker.java
index ef74819f073..02055ad60e9 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/MarkupChecker.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/MarkupChecker.java
@@ -1,8 +1,3 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
 package edu.harvard.iq.dataverse.util;
 
 import org.apache.commons.text.StringEscapeUtils;
@@ -11,56 +6,105 @@
 import org.jsoup.parser.Parser;
 
 /**
- * Wrapper for Jsoup clean
- * 
+ * Provides utility methods for sanitizing and processing HTML content.
+ * <p>
+ * This class serves as a wrapper for the {@code Jsoup.clean} method and offers
+ * multiple configurations for cleaning HTML input. It also provides a method
+ * for escaping HTML entities and stripping all HTML tags.
+ * </p>
+ *
  * @author rmp553
  */
 public class MarkupChecker {
-    
-    
-    
+
     /**
-     * Wrapper around Jsoup clean method with the basic Safe list
-     *   http://jsoup.org/cookbook/cleaning-html/safelist-sanitizer
-     * @param unsafe
-     * @return 
+     * Sanitizes the provided HTML content using a customizable configuration.
+     * <p>
+     * This method uses the {@code Jsoup.clean} method with a configurable {@code Safelist}.
+     * For more details, see the
+     * <a href="http://jsoup.org/cookbook/cleaning-html/safelist-sanitizer">Jsoup SafeList Sanitizer</a>.
+     * </p>
+     * <p>
+     * It supports preserving class attributes and optionally adding "noopener noreferrer nofollow"
+     * attributes to anchor tags to enhance security and usability.
+     * </p>
+     *
+     * @param unsafe                    the HTML content to be sanitized; may contain unsafe or untrusted elements.
+     * @param keepClasses               whether to preserve class attributes in the sanitized HTML.
+     * @param includeNoopenerNoreferrer whether to add "noopener noreferrer nofollow" to <a> tags.
+     * @return a sanitized HTML string, free from potentially harmful content.
      */
-    public static String sanitizeBasicHTML(String unsafe) {
-
+    private static String sanitizeHTML(String unsafe, boolean keepClasses, boolean includeNoopenerNoreferrer) {
         if (unsafe == null) {
             return null;
         }
-        // basic includes: a, b, blockquote, br, cite, code, dd, dl, dt, em, i, li, ol, p, pre, q, small, span, strike, strong, sub, sup, u, ul
-        //Whitelist wl = Whitelist.basic().addTags("img", "h1", "h2", "h3", "kbd", "hr", "s", "del");  
 
-        Safelist sl = Safelist.basicWithImages().addTags("h1", "h2", "h3", "kbd", "hr", "s", "del", "map", "area").addAttributes("img", "usemap")
-                .addAttributes("map", "name").addAttributes("area", "shape", "coords", "href", "title", "alt")
+        // Create a base Safelist configuration
+        Safelist sl = Safelist.basicWithImages()
+                .addTags("h1", "h2", "h3", "kbd", "hr", "s", "del", "map", "area")
+                .addAttributes("img", "usemap")
+                .addAttributes("map", "name")
+                .addAttributes("area", "shape", "coords", "href", "title", "alt")
                 .addEnforcedAttribute("a", "target", "_blank");
 
+        // Add class attributes if requested
+        if (keepClasses) {
+            sl.addAttributes(":all", "class");
+        }
+
+        // Add "noopener noreferrer nofollow" to <a> tags if requested
+        if (includeNoopenerNoreferrer) {
+            sl.addEnforcedAttribute("a", "rel", "noopener noreferrer nofollow");
+        }
+
         return Jsoup.clean(unsafe, sl);
+    }
 
+    /**
+     * Sanitizes the provided HTML content using a basic configuration.
+     *
+     * @param unsafe the HTML content to be sanitized; may contain unsafe or untrusted elements.
+     * @return a sanitized HTML string, free from potentially harmful content.
+     */
+    public static String sanitizeBasicHTML(String unsafe) {
+        return sanitizeHTML(unsafe, false, false);
     }
-        
+
     /**
-     * Strip all HTMl tags
-     * 
-     * http://jsoup.org/apidocs/org/jsoup/safety/Safelist.html#none
-     * 
-     * @param unsafe
-     * @return 
+     * Sanitizes the provided HTML content using an advanced configuration.
+     * <p>
+     * This configuration preserves class attributes and adds "noopener noreferrer nofollow"
+     * attributes to <a> tags to enhance security and usability.
+     * </p>
+     *
+     * @param unsafe the HTML content to be sanitized; may contain unsafe or untrusted elements.
+     * @return a sanitized HTML string, free from potentially harmful content.
      */
-    public static String stripAllTags(String unsafe) {
+    public static String sanitizeAdvancedHTML(String unsafe) {
+        return sanitizeHTML(unsafe, true, true);
+    }
 
+    /**
+     * Removes all HTML tags from the provided content, leaving only plain text.
+     *
+     * @param unsafe the HTML content to process; may contain HTML tags.
+     * @return the plain text content with all HTML tags removed, or {@code null} if the input is {@code null}.
+     */
+    public static String stripAllTags(String unsafe) {
         if (unsafe == null) {
             return null;
         }
 
         return Parser.unescapeEntities(Jsoup.clean(unsafe, Safelist.none()), true);
-
     }
-    
+
+    /**
+     * Escapes special characters in the provided string into their corresponding HTML entities.
+     *
+     * @param unsafe the string to escape; may contain special characters.
+     * @return a string with HTML entities escaped.
+     */
     public static String escapeHtml(String unsafe) {
-         return StringEscapeUtils.escapeHtml4(unsafe);
+        return StringEscapeUtils.escapeHtml4(unsafe);
     }
-
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
index b291eedc751..b88dfaef4b5 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
@@ -25,6 +25,7 @@
 import edu.harvard.iq.dataverse.datavariable.VariableCategory;
 import edu.harvard.iq.dataverse.datavariable.VariableMetadata;
 import edu.harvard.iq.dataverse.datavariable.VariableRange;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
 import edu.harvard.iq.dataverse.license.License;
 import edu.harvard.iq.dataverse.globus.FileDetailsHolder;
 import edu.harvard.iq.dataverse.harvest.client.HarvestingClient;
@@ -1458,4 +1459,21 @@ private static JsonObjectBuilder jsonDataverseInputLevel(DataverseFieldTypeInput
         jsonObjectBuilder.add("include", inputLevel.isInclude());
         return jsonObjectBuilder;
     }
+
+    public static JsonArrayBuilder jsonDataverseFeaturedItems(List<DataverseFeaturedItem> dataverseFeaturedItems) {
+        JsonArrayBuilder featuredItemsArrayBuilder = Json.createArrayBuilder();
+        for (DataverseFeaturedItem dataverseFeaturedItem : dataverseFeaturedItems) {
+            featuredItemsArrayBuilder.add(json(dataverseFeaturedItem));
+        }
+        return featuredItemsArrayBuilder;
+    }
+
+    public static JsonObjectBuilder json(DataverseFeaturedItem dataverseFeaturedItem) {
+        return jsonObjectBuilder()
+                .add("id", dataverseFeaturedItem.getId())
+                .add("content", dataverseFeaturedItem.getContent())
+                .add("imageFileName", dataverseFeaturedItem.getImageFileName())
+                .add("imageFileUrl", dataverseFeaturedItem.getImageFileUrl())
+                .add("displayOrder", dataverseFeaturedItem.getDisplayOrder());
+    }
 }
diff --git a/src/main/java/propertyFiles/Bundle.properties b/src/main/java/propertyFiles/Bundle.properties
index 765c5e17882..22528bb1889 100644
--- a/src/main/java/propertyFiles/Bundle.properties
+++ b/src/main/java/propertyFiles/Bundle.properties
@@ -1003,6 +1003,14 @@ dataverse.metadatablocks.error.invalidmetadatablockname=Invalid metadata block n
 dataverse.metadatablocks.error.containslistandinheritflag=Metadata block can not contain both {0} and {1}: true
 dataverse.create.error.jsonparse=Error parsing Json: {0}
 dataverse.create.error.jsonparsetodataverse=Error parsing the POSTed json into a dataverse: {0}
+dataverse.create.featuredItem.error.imageFileProcessing=Error processing featured item file: {0}
+dataverse.create.featuredItem.error.fileSizeExceedsLimit=File exceeds the maximum size of {0}
+dataverse.create.featuredItem.error.invalidFileType=Invalid image file type
+dataverse.create.featuredItem.error.contentShouldBeProvided=Featured item 'content' property should be provided and not empty.
+dataverse.create.featuredItem.error.contentExceedsLengthLimit=Featured item content exceeds the maximum allowed length of {0} characters.
+dataverse.update.featuredItems.error.missingInputParams=All input parameters (id, content, displayOrder, keepFile, fileName) are required.
+dataverse.update.featuredItems.error.inputListsSizeMismatch=All input lists (id, content, displayOrder, keepFile, fileName) must have the same size.
+dataverse.delete.featuredItems.success=All featured items of this Dataverse have been successfully deleted.
 # rolesAndPermissionsFragment.xhtml
 
 # advanced.xhtml
@@ -2815,6 +2823,7 @@ dataverses.api.create.dataset.error.mustIncludeAuthorName=Please provide author
 dataverses.api.validate.json.succeeded=The Dataset JSON provided is valid for this Dataverse Collection.
 dataverses.api.validate.json.failed=The Dataset JSON provided failed validation with the following error:
 dataverses.api.validate.json.exception=Validation failed with following exception:
+dataverses.api.update.featured.items.error.onlyImageFilesAllowed=Invalid file type. Only image files are allowed.
 
 #Access.java
 access.api.allowRequests.failure.noDataset=Could not find Dataset with id: {0}
@@ -3134,3 +3143,7 @@ bearerTokenAuthMechanism.errors.tokenValidatedButNoRegisteredUser=Bearer token i
 authenticationServiceBean.errors.unauthorizedBearerToken=Unauthorized bearer token.
 authenticationServiceBean.errors.invalidBearerToken=Could not parse bearer token.
 authenticationServiceBean.errors.bearerTokenDetectedNoOIDCProviderConfigured=Bearer token detected, no OIDC provider configured.
+
+#DataverseFeaturedItems.java
+dataverseFeaturedItems.errors.notFound=Could not find dataverse featured item with identifier {0}
+dataverseFeaturedItems.delete.successful=Successfully deleted dataverse featured item with identifier {0}
diff --git a/src/main/resources/META-INF/microprofile-config.properties b/src/main/resources/META-INF/microprofile-config.properties
index b0bc92cf975..95f30b6ba1d 100644
--- a/src/main/resources/META-INF/microprofile-config.properties
+++ b/src/main/resources/META-INF/microprofile-config.properties
@@ -19,6 +19,8 @@ dataverse.files.directory=${STORAGE_DIR:/tmp/dataverse}
 dataverse.files.uploads=${STORAGE_DIR:${com.sun.aas.instanceRoot}}/uploads
 dataverse.files.docroot=${STORAGE_DIR:${com.sun.aas.instanceRoot}}/docroot
 dataverse.files.globus-cache-maxage=5
+dataverse.files.featured-items.image-maxsize=1000000
+dataverse.files.featured-items.image-uploads=featuredItems
 
 # SEARCH INDEX
 dataverse.solr.host=localhost
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataverseFeaturedItemsIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataverseFeaturedItemsIT.java
new file mode 100644
index 00000000000..032c1739d53
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataverseFeaturedItemsIT.java
@@ -0,0 +1,112 @@
+package edu.harvard.iq.dataverse.api;
+
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import io.restassured.RestAssured;
+import io.restassured.path.json.JsonPath;
+import io.restassured.response.Response;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.text.MessageFormat;
+
+import static jakarta.ws.rs.core.Response.Status.*;
+import static org.hamcrest.CoreMatchers.equalTo;
+
+public class DataverseFeaturedItemsIT {
+
+    @BeforeAll
+    public static void setUpClass() {
+        RestAssured.baseURI = UtilIT.getRestAssuredBaseUri();
+    }
+
+    @Test
+    public void testDeleteFeaturedItem() {
+        String apiToken = createUserAndGetApiToken();
+        String dataverseAlias = createDataverseAndGetAlias(apiToken);
+        Long featuredItemId = createFeaturedItemAndGetId(dataverseAlias, apiToken, "src/test/resources/images/coffeeshop.png");
+
+        // Should return not found when passing incorrect item id
+        Response deleteFeatureItemResponse = UtilIT.deleteDataverseFeaturedItem(100000L, apiToken);
+        deleteFeatureItemResponse.then()
+                .body("message", equalTo(MessageFormat.format(BundleUtil.getStringFromBundle("dataverseFeaturedItems.errors.notFound"), 100000L)))
+                .assertThat().statusCode(NOT_FOUND.getStatusCode());
+
+        // Should return unauthorized when passing correct id and user does not have permissions
+        String randomUserApiToken = createUserAndGetApiToken();
+        deleteFeatureItemResponse = UtilIT.deleteDataverseFeaturedItem(featuredItemId, randomUserApiToken);
+        deleteFeatureItemResponse.then().assertThat().statusCode(UNAUTHORIZED.getStatusCode());
+
+        // Should delete featured item when passing correct id and user has permissions
+        deleteFeatureItemResponse = UtilIT.deleteDataverseFeaturedItem(featuredItemId, apiToken);
+        deleteFeatureItemResponse.then()
+                .body("data.message", equalTo(MessageFormat.format(BundleUtil.getStringFromBundle("dataverseFeaturedItems.delete.successful"), featuredItemId)))
+                .assertThat().statusCode(OK.getStatusCode());
+
+        Response listFeaturedItemsResponse = UtilIT.listDataverseFeaturedItems(dataverseAlias, apiToken);
+        listFeaturedItemsResponse.then()
+                .body("data.size()", equalTo(0))
+                .assertThat().statusCode(OK.getStatusCode());
+    }
+
+    @Test
+    public void testUpdateFeaturedItem() {
+        String apiToken = createUserAndGetApiToken();
+        String dataverseAlias = createDataverseAndGetAlias(apiToken);
+        Long featuredItemId = createFeaturedItemAndGetId(dataverseAlias, apiToken, "src/test/resources/images/coffeeshop.png");
+
+        // Should return not found when passing incorrect item id
+        Response updateFeatureItemResponse = UtilIT.updateDataverseFeaturedItem(100000L, "updatedTitle", 1, false, null, apiToken);
+        updateFeatureItemResponse.then()
+                .body("message", equalTo(MessageFormat.format(BundleUtil.getStringFromBundle("dataverseFeaturedItems.errors.notFound"), 100000L)))
+                .assertThat().statusCode(NOT_FOUND.getStatusCode());
+
+        // Should return unauthorized when passing correct id and user does not have permissions
+        String randomUserApiToken = createUserAndGetApiToken();
+        updateFeatureItemResponse = UtilIT.updateDataverseFeaturedItem(featuredItemId, "updatedTitle", 1, false, null, randomUserApiToken);
+        updateFeatureItemResponse.then().assertThat().statusCode(UNAUTHORIZED.getStatusCode());
+
+        // Update featured item: keep image file
+        updateFeatureItemResponse = UtilIT.updateDataverseFeaturedItem(featuredItemId, "updatedTitle1", 1, true, null, apiToken);
+        verifyUpdatedFeaturedItem(updateFeatureItemResponse, "updatedTitle1", "coffeeshop.png", 1);
+
+        // Update featured item: remove image file
+        updateFeatureItemResponse = UtilIT.updateDataverseFeaturedItem(featuredItemId, "updatedTitle1", 2, false, null, apiToken);
+        verifyUpdatedFeaturedItem(updateFeatureItemResponse, "updatedTitle1", null, 2);
+
+        // Update featured item: set new image file
+        updateFeatureItemResponse = UtilIT.updateDataverseFeaturedItem(featuredItemId, "updatedTitle1", 2, false, "src/test/resources/images/coffeeshop.png", apiToken);
+        verifyUpdatedFeaturedItem(updateFeatureItemResponse, "updatedTitle1", "coffeeshop.png", 2);
+
+        // Update featured item: set malicious content which should be sanitized
+        String unsafeContent = "<h1 class=\"rte-heading\">A title</h1><a target=\"_blank\" class=\"rte-link\" href=\"https://test.com\">link</a>";
+        String sanitizedContent = "<h1 class=\"rte-heading\">A title</h1><a target=\"_blank\" class=\"rte-link\" href=\"https://test.com\" rel=\"noopener noreferrer nofollow\">link</a>";
+        updateFeatureItemResponse = UtilIT.updateDataverseFeaturedItem(featuredItemId, unsafeContent, 2, false, "src/test/resources/images/coffeeshop.png", apiToken);
+        verifyUpdatedFeaturedItem(updateFeatureItemResponse, sanitizedContent, "coffeeshop.png", 2);
+    }
+
+    private String createUserAndGetApiToken() {
+        Response createUserResponse = UtilIT.createRandomUser();
+        return UtilIT.getApiTokenFromResponse(createUserResponse);
+    }
+
+    private String createDataverseAndGetAlias(String apiToken) {
+        Response createDataverseResponse = UtilIT.createRandomDataverse(apiToken);
+        createDataverseResponse.then().assertThat().statusCode(CREATED.getStatusCode());
+        return UtilIT.getAliasFromResponse(createDataverseResponse);
+    }
+
+    private Long createFeaturedItemAndGetId(String dataverseAlias, String apiToken, String pathToTestFile) {
+        Response createFeatureItemResponse = UtilIT.createDataverseFeaturedItem(dataverseAlias, apiToken, "test", 0, pathToTestFile);
+        createFeatureItemResponse.then().assertThat().statusCode(OK.getStatusCode());
+        JsonPath createdFeaturedItem = JsonPath.from(createFeatureItemResponse.body().asString());
+        return createdFeaturedItem.getLong("data.id");
+    }
+
+    private void verifyUpdatedFeaturedItem(Response response, String expectedContent, String expectedImageFileName, int expectedDisplayOrder) {
+        response.then().assertThat()
+                .body("data.content", equalTo(expectedContent))
+                .body("data.imageFileName", equalTo(expectedImageFileName))
+                .body("data.displayOrder", equalTo(expectedDisplayOrder))
+                .statusCode(OK.getStatusCode());
+    }
+}
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index bd798b931ad..825465fcd9e 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -1645,4 +1645,285 @@ public void testGetUserPermissionsOnDataverse() {
         Response getUserPermissionsOnDataverseInvalidIdResponse = UtilIT.getUserPermissionsOnDataverse("testInvalidAlias", apiToken);
         getUserPermissionsOnDataverseInvalidIdResponse.then().assertThat().statusCode(NOT_FOUND.getStatusCode());
     }
+
+    @Test
+    public void testCreateFeaturedItem() {
+        Response createUserResponse = UtilIT.createRandomUser();
+        String apiToken = UtilIT.getApiTokenFromResponse(createUserResponse);
+        Response createDataverseResponse = UtilIT.createRandomDataverse(apiToken);
+        createDataverseResponse.then().assertThat().statusCode(CREATED.getStatusCode());
+        String dataverseAlias = UtilIT.getAliasFromResponse(createDataverseResponse);
+
+        // Should not return any error when not passing a file
+
+        Response createFeatureItemResponse = UtilIT.createDataverseFeaturedItem(dataverseAlias, apiToken, "test", 0, null);
+        createFeatureItemResponse.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.content", equalTo("test"))
+                .body("data.imageFileName", equalTo(null))
+                .body("data.displayOrder", equalTo(0));
+
+        // Should not return any error when passing correct file and data
+
+        String pathToTestFile = "src/test/resources/images/coffeeshop.png";
+        createFeatureItemResponse = UtilIT.createDataverseFeaturedItem(dataverseAlias, apiToken, "test", 1, pathToTestFile);
+        createFeatureItemResponse.then().assertThat()
+                .body("data.content", equalTo("test"))
+                .body("data.imageFileName", equalTo("coffeeshop.png"))
+                .body("data.displayOrder", equalTo(1))
+                .statusCode(OK.getStatusCode());
+
+        // Should return bad request error when passing incorrect file type
+
+        pathToTestFile = "src/test/resources/tab/test.tab";
+        createFeatureItemResponse = UtilIT.createDataverseFeaturedItem(dataverseAlias, apiToken, "test", 0, pathToTestFile);
+        createFeatureItemResponse.then().assertThat()
+                .body("message", equalTo(BundleUtil.getStringFromBundle("dataverse.create.featuredItem.error.invalidFileType")))
+                .statusCode(BAD_REQUEST.getStatusCode());
+
+        // Should return unauthorized error when user has no permissions
+
+        Response createRandomUser = UtilIT.createRandomUser();
+        String randomUserApiToken = UtilIT.getApiTokenFromResponse(createRandomUser);
+        createFeatureItemResponse = UtilIT.createDataverseFeaturedItem(dataverseAlias, randomUserApiToken, "test", 0, pathToTestFile);
+        createFeatureItemResponse.then().assertThat().statusCode(UNAUTHORIZED.getStatusCode());
+
+        // Should return not found error when dataverse does not exist
+
+        createFeatureItemResponse = UtilIT.createDataverseFeaturedItem("thisDataverseDoesNotExist", apiToken, "test", 0, pathToTestFile);
+        createFeatureItemResponse.then().assertThat()
+                .body("message", equalTo("Can't find dataverse with identifier='thisDataverseDoesNotExist'"))
+                .statusCode(NOT_FOUND.getStatusCode());
+    }
+
+    @Test
+    public void testListFeaturedItems() {
+        Response createUserResponse = UtilIT.createRandomUser();
+        String apiToken = UtilIT.getApiTokenFromResponse(createUserResponse);
+        Response createDataverseResponse = UtilIT.createRandomDataverse(apiToken);
+        createDataverseResponse.then().assertThat().statusCode(CREATED.getStatusCode());
+        String dataverseAlias = UtilIT.getAliasFromResponse(createDataverseResponse);
+
+        // Create test items
+
+        List<Long> ids = Arrays.asList(0L, 0L, 0L);
+        List<String> contents = Arrays.asList("Content 1", "Content 2", "Content 3");
+        List<Integer> orders = Arrays.asList(2, 1, 0);
+        List<Boolean> keepFiles = Arrays.asList(false, false, false);
+        List<String> pathsToFiles = Arrays.asList("src/test/resources/images/coffeeshop.png", null, null);
+
+        Response updateDataverseFeaturedItemsResponse = UtilIT.updateDataverseFeaturedItems(dataverseAlias, ids, contents, orders, keepFiles, pathsToFiles, apiToken);
+        updateDataverseFeaturedItemsResponse.then().assertThat()
+                .statusCode(OK.getStatusCode());
+
+        // Items should be retrieved with all their properties and sorted by displayOrder
+
+        Response listDataverseFeaturedItemsResponse = UtilIT.listDataverseFeaturedItems(dataverseAlias, apiToken);
+        listDataverseFeaturedItemsResponse.then().assertThat()
+                .body("data.size()", equalTo(3))
+                .body("data[0].content", equalTo("Content 3"))
+                .body("data[0].imageFileName", equalTo(null))
+                .body("data[0].imageFileUrl", equalTo(null))
+                .body("data[0].displayOrder", equalTo(0))
+                .body("data[1].content", equalTo("Content 2"))
+                .body("data[1].imageFileName", equalTo(null))
+                .body("data[1].imageFileUrl", equalTo(null))
+                .body("data[1].displayOrder", equalTo(1))
+                .body("data[2].content", equalTo("Content 1"))
+                .body("data[2].imageFileName", equalTo("coffeeshop.png"))
+                .body("data[2].imageFileUrl", containsString("/api/access/dataverseFeaturedItemImage/"))
+                .body("data[2].displayOrder", equalTo(2))
+                .statusCode(OK.getStatusCode());
+
+        // Should return not found error when dataverse does not exist
+
+        listDataverseFeaturedItemsResponse = UtilIT.listDataverseFeaturedItems("thisDataverseDoesNotExist", apiToken);
+        listDataverseFeaturedItemsResponse.then().assertThat()
+                .body("message", equalTo("Can't find dataverse with identifier='thisDataverseDoesNotExist'"))
+                .statusCode(NOT_FOUND.getStatusCode());
+
+    }
+
+    @Test
+    public void testUpdateFeaturedItems() {
+        Response createUserResponse = UtilIT.createRandomUser();
+        String apiToken = UtilIT.getApiTokenFromResponse(createUserResponse);
+        Response createDataverseResponse = UtilIT.createRandomDataverse(apiToken);
+        createDataverseResponse.then().assertThat().statusCode(CREATED.getStatusCode());
+        String dataverseAlias = UtilIT.getAliasFromResponse(createDataverseResponse);
+        String baseUri = UtilIT.getRestAssuredBaseUri();
+
+        // Create new items
+
+        List<Long> ids = Arrays.asList(0L, 0L, 0L);
+        List<String> contents = Arrays.asList("Content 1", "Content 2", "Content 3");
+        List<Integer> orders = Arrays.asList(0, 1, 2);
+        List<Boolean> keepFiles = Arrays.asList(false, false, false);
+        List<String> pathsToFiles = Arrays.asList("src/test/resources/images/coffeeshop.png", null, null);
+
+        Response updateDataverseFeaturedItemsResponse = UtilIT.updateDataverseFeaturedItems(dataverseAlias, ids, contents, orders, keepFiles, pathsToFiles, apiToken);
+        updateDataverseFeaturedItemsResponse.then().assertThat()
+                .body("data.size()", equalTo(3))
+                .body("data[0].content", equalTo("Content 1"))
+                .body("data[0].imageFileName", equalTo("coffeeshop.png"))
+                .body("data[0].imageFileUrl", containsString("/api/access/dataverseFeaturedItemImage/"))
+                .body("data[0].displayOrder", equalTo(0))
+                .body("data[1].content", equalTo("Content 2"))
+                .body("data[1].imageFileName", equalTo(null))
+                .body("data[1].imageFileUrl", equalTo(null))
+                .body("data[1].displayOrder", equalTo(1))
+                .body("data[2].content", equalTo("Content 3"))
+                .body("data[2].imageFileName", equalTo(null))
+                .body("data[2].imageFileUrl", equalTo(null))
+                .body("data[2].displayOrder", equalTo(2))
+                .statusCode(OK.getStatusCode());
+
+        Long firstItemId = JsonPath.from(updateDataverseFeaturedItemsResponse.body().asString()).getLong("data[0].id");
+        Long secondItemId = JsonPath.from(updateDataverseFeaturedItemsResponse.body().asString()).getLong("data[1].id");
+        Long thirdItemId = JsonPath.from(updateDataverseFeaturedItemsResponse.body().asString()).getLong("data[2].id");
+
+        // Update first item (content, order, and keeping image), delete the rest and create new items
+
+        ids = Arrays.asList(firstItemId, 0L, 0L);
+        contents = Arrays.asList("Content 1 updated", "Content 2", "Content 3");
+        orders = Arrays.asList(1, 0, 2);
+        keepFiles = Arrays.asList(true, false, false);
+        pathsToFiles = Arrays.asList(null, null, null);
+
+        updateDataverseFeaturedItemsResponse = UtilIT.updateDataverseFeaturedItems(dataverseAlias, ids, contents, orders, keepFiles, pathsToFiles, apiToken);
+        updateDataverseFeaturedItemsResponse.then().assertThat()
+                .body("data.size()", equalTo(3))
+                .body("data[0].content", equalTo("Content 2"))
+                .body("data[0].imageFileName", equalTo(null))
+                .body("data[0].imageFileUrl", equalTo(null))
+                .body("data[0].displayOrder", equalTo(0))
+                .body("data[1].content", equalTo("Content 1 updated"))
+                .body("data[1].imageFileName", equalTo("coffeeshop.png"))
+                .body("data[1].imageFileUrl", containsString("/api/access/dataverseFeaturedItemImage/"))
+                .body("data[1].displayOrder", equalTo(1))
+                .body("data[2].content", equalTo("Content 3"))
+                .body("data[2].imageFileName", equalTo(null))
+                .body("data[2].imageFileUrl", equalTo(null))
+                .body("data[2].displayOrder", equalTo(2))
+                .statusCode(OK.getStatusCode());
+
+        Long firstItemIdAfterUpdate = JsonPath.from(updateDataverseFeaturedItemsResponse.body().asString()).getLong("data[1].id");
+        Long secondItemIdAfterUpdate = JsonPath.from(updateDataverseFeaturedItemsResponse.body().asString()).getLong("data[0].id");
+        Long thirdItemIdAfterUpdate = JsonPath.from(updateDataverseFeaturedItemsResponse.body().asString()).getLong("data[2].id");
+
+        assertEquals(firstItemId, firstItemIdAfterUpdate);
+        assertNotEquals(secondItemId, secondItemIdAfterUpdate);
+        assertNotEquals(thirdItemId, thirdItemIdAfterUpdate);
+
+        // Update first item (removing image), update second item (adding image), delete the third item and create a new item
+
+        ids = Arrays.asList(firstItemId, secondItemIdAfterUpdate, 0L);
+        contents = Arrays.asList("Content 1 updated", "Content 2", "Content 3");
+        orders = Arrays.asList(1, 0, 2);
+        keepFiles = Arrays.asList(false, false, false);
+        pathsToFiles = Arrays.asList(null, "src/test/resources/images/coffeeshop.png", null);
+
+        updateDataverseFeaturedItemsResponse = UtilIT.updateDataverseFeaturedItems(dataverseAlias, ids, contents, orders, keepFiles, pathsToFiles, apiToken);
+        updateDataverseFeaturedItemsResponse.then().assertThat()
+                .body("data.size()", equalTo(3))
+                .body("data[0].content", equalTo("Content 2"))
+                .body("data[0].imageFileName", equalTo("coffeeshop.png"))
+                .body("data[0].imageFileUrl", containsString("/api/access/dataverseFeaturedItemImage/"))
+                .body("data[0].displayOrder", equalTo(0))
+                .body("data[1].content", equalTo("Content 1 updated"))
+                .body("data[1].imageFileName", equalTo(null))
+                .body("data[1].imageFileUrl", equalTo(null))
+                .body("data[1].displayOrder", equalTo(1))
+                .body("data[2].content", equalTo("Content 3"))
+                .body("data[2].imageFileName", equalTo(null))
+                .body("data[2].imageFileUrl", equalTo(null))
+                .body("data[2].displayOrder", equalTo(2))
+                .statusCode(OK.getStatusCode());
+
+        Long firstItemIdAfterSecondUpdate = JsonPath.from(updateDataverseFeaturedItemsResponse.body().asString()).getLong("data[1].id");
+        Long secondItemIdAfterSecondUpdate = JsonPath.from(updateDataverseFeaturedItemsResponse.body().asString()).getLong("data[0].id");
+        Long thirdItemIdAfterSecondUpdate = JsonPath.from(updateDataverseFeaturedItemsResponse.body().asString()).getLong("data[2].id");
+
+        assertEquals(firstItemId, firstItemIdAfterSecondUpdate);
+        assertEquals(secondItemIdAfterUpdate, secondItemIdAfterSecondUpdate);
+        assertNotEquals(thirdItemIdAfterUpdate, thirdItemIdAfterSecondUpdate);
+
+        // Only keep first featured item
+
+        ids = List.of(firstItemId);
+        contents = List.of("Content 1 updated");
+        orders = List.of(0);
+        keepFiles = List.of(false);
+        pathsToFiles = null;
+
+        updateDataverseFeaturedItemsResponse = UtilIT.updateDataverseFeaturedItems(dataverseAlias, ids, contents, orders, keepFiles, pathsToFiles, apiToken);
+        updateDataverseFeaturedItemsResponse.then().assertThat()
+                .body("data.size()", equalTo(1))
+                .body("data[0].content", equalTo("Content 1 updated"))
+                .body("data[0].imageFileName", equalTo(null))
+                .body("data[0].imageFileUrl", equalTo(null))
+                .body("data[0].displayOrder", equalTo(0))
+                .statusCode(OK.getStatusCode());
+
+        // Should return unauthorized error when user has no permissions
+
+        Response createRandomUser = UtilIT.createRandomUser();
+        String randomUserApiToken = UtilIT.getApiTokenFromResponse(createRandomUser);
+        updateDataverseFeaturedItemsResponse = UtilIT.updateDataverseFeaturedItems(dataverseAlias, ids, contents, orders, keepFiles, pathsToFiles, randomUserApiToken);
+        updateDataverseFeaturedItemsResponse.then().assertThat().statusCode(UNAUTHORIZED.getStatusCode());
+
+        // Should return not found error when dataverse does not exist
+
+        updateDataverseFeaturedItemsResponse = UtilIT.updateDataverseFeaturedItems("thisDataverseDoesNotExist", ids, contents, orders, keepFiles, pathsToFiles, apiToken);
+        updateDataverseFeaturedItemsResponse.then().assertThat()
+                .body("message", equalTo("Can't find dataverse with identifier='thisDataverseDoesNotExist'"))
+                .statusCode(NOT_FOUND.getStatusCode());
+    }
+
+    @Test
+    public void testDeleteFeaturedItems() {
+        Response createUserResponse = UtilIT.createRandomUser();
+        String apiToken = UtilIT.getApiTokenFromResponse(createUserResponse);
+        Response createDataverseResponse = UtilIT.createRandomDataverse(apiToken);
+        createDataverseResponse.then().assertThat().statusCode(CREATED.getStatusCode());
+        String dataverseAlias = UtilIT.getAliasFromResponse(createDataverseResponse);
+
+        // Create test featured items
+
+        List<Long> ids = Arrays.asList(0L, 0L, 0L);
+        List<String> contents = Arrays.asList("Content 1", "Content 2", "Content 3");
+        List<Integer> orders = Arrays.asList(0, 1, 2);
+        List<Boolean> keepFiles = Arrays.asList(false, false, false);
+        List<String> pathsToFiles = Arrays.asList("src/test/resources/images/coffeeshop.png", null, null);
+
+        Response updateDataverseFeaturedItemsResponse = UtilIT.updateDataverseFeaturedItems(dataverseAlias, ids, contents, orders, keepFiles, pathsToFiles, apiToken);
+        updateDataverseFeaturedItemsResponse.then().assertThat()
+                .body("data.size()", equalTo(3))
+                .statusCode(OK.getStatusCode());
+
+        // Check that the featured items are successfully deleted when calling the delete endpoint
+
+        Response deleteDataverseFeaturedItemsResponse = UtilIT.deleteDataverseFeaturedItems(dataverseAlias, apiToken);
+        deleteDataverseFeaturedItemsResponse.then().assertThat()
+                .statusCode(OK.getStatusCode());
+
+        Response listFeaturedItemsResponse = UtilIT.listDataverseFeaturedItems(dataverseAlias, apiToken);
+        listFeaturedItemsResponse.then()
+                .body("data.size()", equalTo(0))
+                .assertThat().statusCode(OK.getStatusCode());
+
+        // Should return unauthorized error when user has no permissions
+
+        Response createRandomUser = UtilIT.createRandomUser();
+        String randomUserApiToken = UtilIT.getApiTokenFromResponse(createRandomUser);
+        deleteDataverseFeaturedItemsResponse = UtilIT.deleteDataverseFeaturedItems(dataverseAlias, randomUserApiToken);
+        deleteDataverseFeaturedItemsResponse.then().assertThat().statusCode(UNAUTHORIZED.getStatusCode());
+
+        // Should return not found error when dataverse does not exist
+
+        deleteDataverseFeaturedItemsResponse = UtilIT.deleteDataverseFeaturedItems("thisDataverseDoesNotExist", apiToken);
+        deleteDataverseFeaturedItemsResponse.then().assertThat()
+                .body("message", equalTo("Can't find dataverse with identifier='thisDataverseDoesNotExist'"))
+                .statusCode(NOT_FOUND.getStatusCode());
+    }
 }
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
index 6080e7f01ea..cd089db3863 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
@@ -1,12 +1,14 @@
 package edu.harvard.iq.dataverse.api;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
+import edu.harvard.iq.dataverse.api.dto.NewDataverseFeaturedItemDTO;
 import edu.harvard.iq.dataverse.util.json.NullSafeJsonBuilder;
 import io.restassured.http.ContentType;
 import io.restassured.path.json.JsonPath;
 import io.restassured.response.Response;
 
 import java.io.*;
-import java.util.UUID;
+import java.util.*;
 import java.util.logging.Logger;
 import jakarta.json.Json;
 import jakarta.json.JsonObjectBuilder;
@@ -29,15 +31,13 @@
 import org.junit.jupiter.api.Test;
 import edu.harvard.iq.dataverse.settings.SettingsServiceBean;
 import io.restassured.specification.RequestSpecification;
-import java.util.List;
 import com.mashape.unirest.http.Unirest;
 import com.mashape.unirest.http.exceptions.UnirestException;
 import com.mashape.unirest.request.GetRequest;
 import edu.harvard.iq.dataverse.util.FileUtil;
-import java.util.Base64;
 import org.apache.commons.io.IOUtils;
 import java.nio.file.Path;
-import java.util.ArrayList;
+
 import org.apache.commons.lang3.math.NumberUtils;
 import org.hamcrest.BaseMatcher;
 import org.hamcrest.Description;
@@ -52,8 +52,7 @@
 import edu.harvard.iq.dataverse.settings.FeatureFlags;
 import edu.harvard.iq.dataverse.util.StringUtil;
 
-import java.util.Collections;
-
+import static org.apache.http.entity.ContentType.APPLICATION_JSON;
 import static org.junit.jupiter.api.Assertions.*;
 
 public class UtilIT {
@@ -4424,4 +4423,96 @@ static Response performKeycloakROPCLogin(String username, String password) {
                 .formParam("scope", "openid")
                 .post("http://keycloak.mydomain.com:8090/realms/test/protocol/openid-connect/token");
     }
+
+    static Response createDataverseFeaturedItem(String dataverseAlias,
+                                                String apiToken,
+                                                String content,
+                                                int displayOrder,
+                                                String pathToFile) {
+        RequestSpecification requestSpecification = given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .contentType(ContentType.MULTIPART)
+                .multiPart("content", content)
+                .multiPart("displayOrder", displayOrder);
+
+        if (pathToFile != null) {
+            requestSpecification.multiPart("file", new File(pathToFile));
+        }
+
+        return requestSpecification
+                .when()
+                .post("/api/dataverses/" + dataverseAlias + "/featuredItems");
+    }
+
+    static Response deleteDataverseFeaturedItem(long id, String apiToken) {
+        return given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .delete("/api/dataverseFeaturedItems/" + id);
+    }
+
+    static Response updateDataverseFeaturedItem(long featuredItemId,
+                                                String content,
+                                                int displayOrder,
+                                                boolean keepFile,
+                                                String pathToFile,
+                                                String apiToken) {
+        RequestSpecification requestSpecification = given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .contentType(ContentType.MULTIPART)
+                .multiPart("content", content)
+                .multiPart("displayOrder", displayOrder)
+                .multiPart("keepFile", keepFile);
+
+        if (pathToFile != null) {
+            requestSpecification.multiPart("file", new File(pathToFile));
+        }
+
+        return requestSpecification
+                .when()
+                .put("/api/dataverseFeaturedItems/" + featuredItemId);
+    }
+
+    static Response listDataverseFeaturedItems(String dataverseAlias, String apiToken) {
+        return given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .contentType("application/json")
+                .get("/api/dataverses/" + dataverseAlias + "/featuredItems");
+    }
+
+    static Response updateDataverseFeaturedItems(
+            String dataverseAlias,
+            List<Long> ids,
+            List<String> contents,
+            List<Integer> orders,
+            List<Boolean> keepFiles,
+            List<String> pathsToFiles,
+            String apiToken) {
+
+        RequestSpecification requestSpec = given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .contentType(ContentType.MULTIPART);
+
+        for (int i = 0; i < contents.size(); i++) {
+            requestSpec.multiPart("content", contents.get(i))
+                    .multiPart("displayOrder", orders.get(i))
+                    .multiPart("keepFile", keepFiles.get(i))
+                    .multiPart("id", ids.get(i));
+
+            String pathToFile = pathsToFiles != null ? pathsToFiles.get(i) : null;
+            if (pathToFile != null && !pathToFile.isEmpty()) {
+                requestSpec.multiPart("fileName", Paths.get(pathToFile).getFileName().toString())
+                        .multiPart("file", new File(pathToFile));
+            } else {
+                requestSpec.multiPart("fileName", "");
+            }
+        }
+
+        return requestSpec.when().put("/api/dataverses/" + dataverseAlias + "/featuredItems");
+    }
+
+    static Response deleteDataverseFeaturedItems(String dataverseAlias, String apiToken) {
+        return given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .delete("/api/dataverses/" + dataverseAlias + "/featuredItems");
+    }
 }
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/TestCommandContext.java b/src/test/java/edu/harvard/iq/dataverse/engine/TestCommandContext.java
index b4b9c0d33f2..4fec86c5b0b 100644
--- a/src/test/java/edu/harvard/iq/dataverse/engine/TestCommandContext.java
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/TestCommandContext.java
@@ -9,6 +9,7 @@
 import edu.harvard.iq.dataverse.confirmemail.ConfirmEmailServiceBean;
 import edu.harvard.iq.dataverse.datacapturemodule.DataCaptureModuleServiceBean;
 import edu.harvard.iq.dataverse.dataset.DatasetTypeServiceBean;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
 import edu.harvard.iq.dataverse.engine.command.Command;
 import edu.harvard.iq.dataverse.engine.command.CommandContext;
 import edu.harvard.iq.dataverse.ingest.IngestServiceBean;
@@ -246,6 +247,11 @@ public StorageUseServiceBean storageUse() {
         return null;
     }
 
+    @Override
+    public DataverseFeaturedItemServiceBean dataverseFeaturedItems() {
+        return null;
+    }
+
     @Override
     public void beginCommandSequence() {
         throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDataverseFeaturedItemCommandTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDataverseFeaturedItemCommandTest.java
new file mode 100644
index 00000000000..f31299526bd
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/CreateDataverseFeaturedItemCommandTest.java
@@ -0,0 +1,168 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
+import edu.harvard.iq.dataverse.api.dto.NewDataverseFeaturedItemDTO;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.text.MessageFormat;
+import java.util.List;
+
+import static edu.harvard.iq.dataverse.mocks.MocksFactory.makeRequest;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+class CreateDataverseFeaturedItemCommandTest {
+    @Mock
+    private CommandContext contextStub;
+
+    @Mock
+    private DataverseFeaturedItemServiceBean dataverseFeaturedItemServiceStub;
+
+    @InjectMocks
+    private CreateDataverseFeaturedItemCommand sut;
+
+    private Dataverse testDataverse;
+    private NewDataverseFeaturedItemDTO testNewDataverseFeaturedItemDTO;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+
+        testDataverse = new Dataverse();
+        testDataverse.setId(123L);
+
+        testNewDataverseFeaturedItemDTO = new NewDataverseFeaturedItemDTO();
+        testNewDataverseFeaturedItemDTO.setImageFileName("test.png");
+        testNewDataverseFeaturedItemDTO.setContent("test content");
+        testNewDataverseFeaturedItemDTO.setDisplayOrder(0);
+        testNewDataverseFeaturedItemDTO.setImageFileInputStream(mock(InputStream.class));
+
+        when(contextStub.dataverseFeaturedItems()).thenReturn(dataverseFeaturedItemServiceStub);
+        sut = new CreateDataverseFeaturedItemCommand(makeRequest(), testDataverse, testNewDataverseFeaturedItemDTO);
+    }
+
+    @Test
+    void execute_imageFileProvidedAndValid_savesFeaturedItem() throws Exception {
+        DataverseFeaturedItem expectedFeaturedItem = new DataverseFeaturedItem();
+        expectedFeaturedItem.setDataverse(testDataverse);
+        expectedFeaturedItem.setImageFileName(testNewDataverseFeaturedItemDTO.getImageFileName());
+        expectedFeaturedItem.setDisplayOrder(testNewDataverseFeaturedItemDTO.getDisplayOrder());
+        expectedFeaturedItem.setContent(testNewDataverseFeaturedItemDTO.getContent());
+
+        when(dataverseFeaturedItemServiceStub.save(any(DataverseFeaturedItem.class))).thenReturn(expectedFeaturedItem);
+
+        DataverseFeaturedItem result = sut.execute(contextStub);
+
+        assertNotNull(result);
+
+        assertEquals(testNewDataverseFeaturedItemDTO.getImageFileName(), result.getImageFileName());
+        assertEquals(testNewDataverseFeaturedItemDTO.getDisplayOrder(), result.getDisplayOrder());
+        assertEquals(testNewDataverseFeaturedItemDTO.getContent(), result.getContent());
+        assertEquals(testDataverse, result.getDataverse());
+
+        verify(dataverseFeaturedItemServiceStub).save(any(DataverseFeaturedItem.class));
+        verify(dataverseFeaturedItemServiceStub).saveDataverseFeaturedItemImageFile(
+                testNewDataverseFeaturedItemDTO.getImageFileInputStream(),
+                testNewDataverseFeaturedItemDTO.getImageFileName(),
+                testDataverse.getId()
+        );
+    }
+
+    @Test
+    void execute_noImageFileProvided_featuredItemSavedWithoutImage() throws Exception {
+        testNewDataverseFeaturedItemDTO.setImageFileName(null);
+
+        DataverseFeaturedItem expectedFeaturedItem = new DataverseFeaturedItem();
+        when(dataverseFeaturedItemServiceStub.save(any(DataverseFeaturedItem.class))).thenReturn(expectedFeaturedItem);
+
+        DataverseFeaturedItem result = sut.execute(contextStub);
+
+        assertNotNull(result);
+        verify(dataverseFeaturedItemServiceStub).save(any(DataverseFeaturedItem.class));
+        verify(dataverseFeaturedItemServiceStub, never()).saveDataverseFeaturedItemImageFile(any(), any(), any());
+    }
+
+    @Test
+    void execute_imageFileProcessingFails_throwsCommandException() throws IOException, DataverseFeaturedItemServiceBean.InvalidImageFileException {
+        testNewDataverseFeaturedItemDTO.setImageFileName("invalid.png");
+        InputStream inputStreamMock = mock(InputStream.class);
+        testNewDataverseFeaturedItemDTO.setImageFileInputStream(inputStreamMock);
+
+        doThrow(new IOException("File processing failed"))
+                .when(dataverseFeaturedItemServiceStub)
+                .saveDataverseFeaturedItemImageFile(any(InputStream.class), any(String.class), any(Long.class));
+
+        CommandException exception = assertThrows(CommandException.class, () -> sut.execute(contextStub));
+        assertTrue(exception.getMessage().contains("File processing failed"));
+    }
+
+    @Test
+    void execute_invalidFileTypeProvided_throwsInvalidCommandArgumentsException() throws IOException, DataverseFeaturedItemServiceBean.InvalidImageFileException {
+        testNewDataverseFeaturedItemDTO.setImageFileName("invalid.type");
+        InputStream inputStreamMock = mock(InputStream.class);
+        testNewDataverseFeaturedItemDTO.setImageFileInputStream(inputStreamMock);
+
+        doThrow(new DataverseFeaturedItemServiceBean.InvalidImageFileException("Invalid file type"))
+                .when(dataverseFeaturedItemServiceStub).saveDataverseFeaturedItemImageFile(any(InputStream.class), any(String.class), any(Long.class));
+
+        InvalidCommandArgumentsException exception = assertThrows(InvalidCommandArgumentsException.class, () -> sut.execute(contextStub));
+        assertTrue(exception.getMessage().contains("Invalid file type"));
+    }
+
+    @Test
+    void execute_contentIsNull_throwsInvalidCommandArgumentsException() {
+        assertContentShouldBeProvidedInvalidCommandArgumentsException(null);
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {" ", ""})
+    void execute_contentIsEmpty_throwsInvalidCommandArgumentsException(String content) {
+        assertContentShouldBeProvidedInvalidCommandArgumentsException(content);
+    }
+
+    @Test
+    void execute_contentExceedsLimit_throwsInvalidCommandArgumentsException() {
+        testNewDataverseFeaturedItemDTO.setContent(createContentExceedingMaxLength());
+        InputStream inputStreamMock = mock(InputStream.class);
+        testNewDataverseFeaturedItemDTO.setImageFileInputStream(inputStreamMock);
+
+        InvalidCommandArgumentsException exception = assertThrows(InvalidCommandArgumentsException.class, () -> sut.execute(contextStub));
+        assertEquals(
+                MessageFormat.format(
+                        BundleUtil.getStringFromBundle("dataverse.create.featuredItem.error.contentExceedsLengthLimit"),
+                        List.of(DataverseFeaturedItem.MAX_FEATURED_ITEM_CONTENT_SIZE)
+                ),
+                exception.getMessage()
+        );
+    }
+
+    private void assertContentShouldBeProvidedInvalidCommandArgumentsException(String content) {
+        testNewDataverseFeaturedItemDTO.setContent(content);
+        InputStream inputStreamMock = mock(InputStream.class);
+        testNewDataverseFeaturedItemDTO.setImageFileInputStream(inputStreamMock);
+
+        InvalidCommandArgumentsException exception = assertThrows(InvalidCommandArgumentsException.class, () -> sut.execute(contextStub));
+        assertEquals(
+                BundleUtil.getStringFromBundle("dataverse.create.featuredItem.error.contentShouldBeProvided"),
+                exception.getMessage()
+        );
+    }
+
+    private String createContentExceedingMaxLength() {
+        return "a".repeat(Math.max(0, DataverseFeaturedItem.MAX_FEATURED_ITEM_CONTENT_SIZE + 1));
+    }
+}
diff --git a/src/test/java/edu/harvard/iq/dataverse/util/MarkupCheckerTest.java b/src/test/java/edu/harvard/iq/dataverse/util/MarkupCheckerTest.java
index 07876e56eb8..02219059db3 100644
--- a/src/test/java/edu/harvard/iq/dataverse/util/MarkupCheckerTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/util/MarkupCheckerTest.java
@@ -23,12 +23,51 @@ public class MarkupCheckerTest {
         "'<h1>hello</h2>', '<h1>hello</h1>'",
         "'the <a href=\"http://dataverse.org\" target=\"_blank\">Dataverse project</a> in a new window', 'the <a href=\"http://dataverse.org\" target=\"_blank\" rel=\"nofollow\">Dataverse project</a> in a new window'",
         "'the <a href=\"http://dataverse.org\">Dataverse project</a> in a new window', 'the <a href=\"http://dataverse.org\" rel=\"nofollow\" target=\"_blank\">Dataverse project</a> in a new window'",
+        // make sure we keep text as it is when it is not html
+        "'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.'",
         "NULL, NULL"
     }, nullValues = {"NULL"})
     public void testSanitizeBasicHTML(String unsafe, String safe) {
         assertEquals(safe, MarkupChecker.sanitizeBasicHTML(unsafe));
     }
 
+    /**
+     * Test of sanitizeAdvancedHTML method, of class MarkupChecker.
+     */
+    @ParameterizedTest
+    @CsvSource(value = {
+        "<script>alert('hi')</script>, ''",
+        "'<map name=\"rtdcCO\">', '<map name=\"rtdcCO\"></map>'",
+        // make sure we do not destroy the <area> tags
+        "'<area shape=\"rect\" coords=\"42,437,105,450\" href=\"/dvn/dv/rtdc/faces/study/StudyPage.xhtml?globalId=hdl:10904/10006\" title=\"Galactic Center (DHT02)\" alt=\"Galactic Center (DHT02)\">', '<area shape=\"rect\" coords=\"42,437,105,450\" href=\"/dvn/dv/rtdc/faces/study/StudyPage.xhtml?globalId=hdl:10904/10006\" title=\"Galactic Center (DHT02)\" alt=\"Galactic Center (DHT02)\">'",
+        // make sure we do not destroy the <map> tags
+        "'<map name=\"rtdcCO\"><area shape=\"rect\" coords=\"42,437,105,450\" href=\"/dvn/dv/rtdc/faces/study/StudyPage.xhtml?globalId=hdl:10904/10006\" title=\"Galactic Center (DHT02)\" alt=\"Galactic Center (DHT02)\"></map>', '<map name=\"rtdcCO\"><area shape=\"rect\" coords=\"42,437,105,450\" href=\"/dvn/dv/rtdc/faces/study/StudyPage.xhtml?globalId=hdl:10904/10006\" title=\"Galactic Center (DHT02)\" alt=\"Galactic Center (DHT02)\"></map>'",
+        "'<p>hello</', '<p>hello&lt;/</p>'",
+        "'<h1>hello</h2>', '<h1>hello</h1>'",
+        // make sure we keep text as it is when it is not html
+        "'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.'",
+        // Should add noopener noreferrer attributes to <a> tags and keep classes
+        "'<h1 class=\"rte-heading\">A title</h1><p class=\"rte-paragraph\">Lorem ipsum<strong class=\"rte-bold\">test</strong><a target=\"_blank\" class=\"rte-link\" href=\"https://test.com\">link</a></p>', '<h1 class=\"rte-heading\">A title</h1><p class=\"rte-paragraph\">Lorem ipsum<strong class=\"rte-bold\">test</strong><a target=\"_blank\" class=\"rte-link\" href=\"https://test.com\" rel=\"noopener noreferrer nofollow\">link</a></p>'",
+        "NULL, NULL"
+    }, nullValues = {"NULL"})
+    public void testSanitizeAdvancedHTML(String unsafe, String safe) {
+        String sanitizedOutput = MarkupChecker.sanitizeAdvancedHTML(unsafe);
+
+        // Normalize both the expected and actual content by removing whitespaces
+
+        String normalizedSafe = null;
+        if (safe != null) {
+            normalizedSafe = safe.replaceAll("\\s+", "").trim();
+        }
+
+        String normalizedOutput = null;
+        if (sanitizedOutput != null) {
+            normalizedOutput = sanitizedOutput.replaceAll("\\s+", "").trim();
+        }
+
+        assertEquals(normalizedSafe, normalizedOutput);
+    }
+
     /**
      * Test of stripAllTags method, of class MarkupChecker.
      */
@@ -37,6 +76,7 @@ public void testSanitizeBasicHTML(String unsafe, String safe) {
         "'', ''",
         "NULL, NULL",
         "Johnson & Johnson <>, Johnson & Johnson <>",
+        "<p>Johnson & Johnson</p>, Johnson & Johnson",
         "Johnson && Johnson <&>&, Johnson && Johnson <&>&"
     }, nullValues = {"NULL"})
     public void testStripAllTags(String unsafe, String safe) {
diff --git a/tests/integration-tests.txt b/tests/integration-tests.txt
index e1dad7a75b1..a20d65e26e3 100644
--- a/tests/integration-tests.txt
+++ b/tests/integration-tests.txt
@@ -1 +1 @@
-DataversesIT,DatasetsIT,SwordIT,AdminIT,BuiltinUsersIT,UsersIT,UtilIT,ConfirmEmailIT,FileMetadataIT,FilesIT,SearchIT,InReviewWorkflowIT,HarvestingServerIT,HarvestingClientsIT,MoveIT,MakeDataCountApiIT,FileTypeDetectionIT,EditDDIIT,ExternalToolsIT,AccessIT,DuplicateFilesIT,DownloadFilesIT,LinkIT,DeleteUsersIT,DeactivateUsersIT,AuxiliaryFilesIT,InvalidCharactersIT,LicensesIT,NotificationsIT,BagIT,MetadataBlocksIT,NetcdfIT,SignpostingIT,FitsIT,LogoutIT,DataRetrieverApiIT,ProvIT,S3AccessIT,OpenApiIT,InfoIT,DatasetFieldsIT,SavedSearchIT,DatasetTypesIT
\ No newline at end of file
+DataversesIT,DatasetsIT,SwordIT,AdminIT,BuiltinUsersIT,UsersIT,UtilIT,ConfirmEmailIT,FileMetadataIT,FilesIT,SearchIT,InReviewWorkflowIT,HarvestingServerIT,HarvestingClientsIT,MoveIT,MakeDataCountApiIT,FileTypeDetectionIT,EditDDIIT,ExternalToolsIT,AccessIT,DuplicateFilesIT,DownloadFilesIT,LinkIT,DeleteUsersIT,DeactivateUsersIT,AuxiliaryFilesIT,InvalidCharactersIT,LicensesIT,NotificationsIT,BagIT,MetadataBlocksIT,NetcdfIT,SignpostingIT,FitsIT,LogoutIT,DataRetrieverApiIT,ProvIT,S3AccessIT,OpenApiIT,InfoIT,DatasetFieldsIT,SavedSearchIT,DatasetTypesIT,DataverseFeaturedItemsIT
\ No newline at end of file