diff --git a/frontend/src/components/Topics/Topic/Messages/Message.tsx b/frontend/src/components/Topics/Topic/Messages/Message.tsx
index 611385d83..c632446aa 100644
--- a/frontend/src/components/Topics/Topic/Messages/Message.tsx
+++ b/frontend/src/components/Topics/Topic/Messages/Message.tsx
@@ -1,15 +1,19 @@
 import React from 'react';
 import useDataSaver from 'lib/hooks/useDataSaver';
-import { TopicMessage } from 'generated-sources';
+import { Action, ResourceType, TopicMessage } from 'generated-sources';
 import MessageToggleIcon from 'components/common/Icons/MessageToggleIcon';
 import IconButtonWrapper from 'components/common/Icons/IconButtonWrapper';
 import { Dropdown, DropdownItem } from 'components/common/Dropdown';
+import { ActionDropdownItem } from 'components/common/ActionComponent';
 import { formatTimestamp } from 'lib/dateTimeHelpers';
 import { JSONPath } from 'jsonpath-plus';
 import Ellipsis from 'components/common/Ellipsis/Ellipsis';
 import WarningRedIcon from 'components/common/Icons/WarningRedIcon';
 import Tooltip from 'components/common/Tooltip/Tooltip';
 import { useTimezone } from 'lib/hooks/useTimezones';
+import useAppParams from 'lib/hooks/useAppParams';
+import { RouteParamsClusterTopic } from 'lib/paths';
+import { useTopicActions } from 'components/contexts/TopicActionsContext';
 
 import MessageContent from './MessageContent/MessageContent';
 import * as S from './MessageContent/MessageContent.styled';
@@ -43,7 +47,24 @@ const Message: React.FC<Props> = ({
   contentFilters,
 }) => {
   const { currentTimezone } = useTimezone();
+  const { topicName } = useAppParams<RouteParamsClusterTopic>();
+  const { openSidebarWithMessage } = useTopicActions();
   const [isOpen, setIsOpen] = React.useState(false);
+
+  const message = {
+    timestamp,
+    timestampType,
+    offset,
+    key,
+    keySize,
+    partition,
+    value,
+    valueSize,
+    headers,
+    valueSerde,
+    keySerde,
+  };
+
   const savedMessageJson = {
     Value: value,
     Offset: offset,
@@ -142,10 +163,28 @@ const Message: React.FC<Props> = ({
         <td style={{ width: '5%' }}>
           {vEllipsisOpen && (
             <Dropdown>
-              <DropdownItem onClick={copyToClipboard}>
+              <DropdownItem
+                aria-label="Copy to clipboard"
+                onClick={copyToClipboard}
+              >
                 Copy to clipboard
               </DropdownItem>
-              <DropdownItem onClick={saveFile}>Save as a file</DropdownItem>
+              <DropdownItem aria-label="Save as a file" onClick={saveFile}>
+                Save as a file
+              </DropdownItem>
+              <ActionDropdownItem
+                aria-label="Reproduce message"
+                onClick={() => {
+                  openSidebarWithMessage(message);
+                }}
+                permission={{
+                  resource: ResourceType.TOPIC,
+                  action: Action.MESSAGES_PRODUCE,
+                  value: topicName,
+                }}
+              >
+                Reproduce message
+              </ActionDropdownItem>
             </Dropdown>
           )}
         </td>
diff --git a/frontend/src/components/Topics/Topic/Messages/__test__/Message.fixtures.ts b/frontend/src/components/Topics/Topic/Messages/__test__/Message.fixtures.ts
new file mode 100644
index 000000000..97d54637d
--- /dev/null
+++ b/frontend/src/components/Topics/Topic/Messages/__test__/Message.fixtures.ts
@@ -0,0 +1,57 @@
+import {
+  Action,
+  ResourceType,
+  TopicMessage,
+  TopicMessageTimestampTypeEnum,
+} from 'generated-sources';
+import { PreviewFilter } from 'components/Topics/Topic/Messages/Message';
+import { RolesType } from 'lib/permissions';
+
+export const mockMessageContentText = 'messageContentText';
+
+export const mockRoles: Map<string, Map<ResourceType, RolesType>> = new Map([
+  [
+    'test-cluster',
+    new Map([
+      [
+        ResourceType.TOPIC,
+        [
+          {
+            resource: ResourceType.TOPIC,
+            actions: [Action.MESSAGES_PRODUCE, Action.VIEW],
+            value: '.*',
+            clusters: ['test-cluster'],
+          },
+        ],
+      ],
+    ]),
+  ],
+]);
+
+export const mockNoRoles: Map<string, Map<ResourceType, RolesType>> = new Map([
+  ['test-cluster', new Map([])],
+]);
+
+export const mockMessageKey = '{"payload":{"subreddit":"learnprogramming"}}';
+
+export const mockMessageValue =
+  '{"payload":{"author":"DwaywelayTOP","archived":false,"name":"t3_11jshwd","id":"11jshwd"}}';
+export const mockMessage: TopicMessage = {
+  timestamp: new Date(),
+  timestampType: TopicMessageTimestampTypeEnum.CREATE_TIME,
+  offset: 0,
+  key: 'test-key',
+  partition: 6,
+  value: '{"data": "test"}',
+  headers: { header: 'test' },
+};
+
+export const mockKeyFilters: PreviewFilter = {
+  field: 'sub',
+  path: '$.payload.subreddit',
+};
+
+export const mockContentFilters: PreviewFilter = {
+  field: 'author',
+  path: '$.payload.author',
+};
diff --git a/frontend/src/components/Topics/Topic/Messages/__test__/Message.spec.tsx b/frontend/src/components/Topics/Topic/Messages/__test__/Message.spec.tsx
index a82ccfbc8..c515ec6b3 100644
--- a/frontend/src/components/Topics/Topic/Messages/__test__/Message.spec.tsx
+++ b/frontend/src/components/Topics/Topic/Messages/__test__/Message.spec.tsx
@@ -1,64 +1,77 @@
 import React from 'react';
-import { TopicMessage, TopicMessageTimestampTypeEnum } from 'generated-sources';
-import Message, {
-  PreviewFilter,
-  Props,
-} from 'components/Topics/Topic/Messages/Message';
-import { screen } from '@testing-library/react';
+import { ResourceType } from 'generated-sources';
+import Message, { Props } from 'components/Topics/Topic/Messages/Message';
+import { act, screen } from '@testing-library/react';
 import { render } from 'lib/testHelpers';
 import userEvent from '@testing-library/user-event';
+import useAppParams from 'lib/hooks/useAppParams';
+import { TopicActionsProvider } from 'components/contexts/TopicActionsContext';
 import { formatTimestamp } from 'lib/dateTimeHelpers';
+import { getDefaultActionMessage } from 'components/common/ActionComponent/ActionComponent';
+import { UserInfoRolesAccessContext } from 'components/contexts/UserInfoRolesAccessContext';
+import { RolesType } from 'lib/permissions';
 
-const messageContentText = 'messageContentText';
+import {
+  mockMessageValue,
+  mockNoRoles,
+  mockMessageKey,
+  mockMessageContentText,
+  mockContentFilters,
+  mockKeyFilters,
+  mockMessage,
+  mockRoles,
+} from './Message.fixtures';
 
-const keyTest = '{"payload":{"subreddit":"learnprogramming"}}';
-const contentTest =
-  '{"payload":{"author":"DwaywelayTOP","archived":false,"name":"t3_11jshwd","id":"11jshwd"}}';
 jest.mock(
   'components/Topics/Topic/Messages/MessageContent/MessageContent',
   () => () => (
     <tr>
-      <td>{messageContentText}</td>
+      <td>{mockMessageContentText}</td>
     </tr>
   )
 );
+jest.mock('lib/hooks/useAppParams');
+
+const mockUseAppParams = jest.mocked(useAppParams);
+const mockOpenSidebarWithMessage = jest.fn();
+const renderComponent = (
+  props: Partial<Props> = {
+    message: mockMessage,
+    keyFilters: [],
+    contentFilters: [],
+  },
+  roles: Map<string, Map<ResourceType, RolesType>> = mockNoRoles
+) =>
+  render(
+    <UserInfoRolesAccessContext.Provider
+      value={{
+        roles,
+        rbacFlag: true,
+        username: 'testUsername',
+      }}
+    >
+      <TopicActionsProvider openSidebarWithMessage={mockOpenSidebarWithMessage}>
+        <table>
+          <tbody>
+            <Message
+              message={props.message || mockMessage}
+              keyFilters={props.keyFilters || []}
+              contentFilters={props.contentFilters || []}
+            />
+          </tbody>
+        </table>
+      </TopicActionsProvider>
+    </UserInfoRolesAccessContext.Provider>
+  );
 
 describe('Message component', () => {
-  const mockMessage: TopicMessage = {
-    timestamp: new Date(),
-    timestampType: TopicMessageTimestampTypeEnum.CREATE_TIME,
-    offset: 0,
-    key: 'test-key',
-    partition: 6,
-    value: '{"data": "test"}',
-    headers: { header: 'test' },
-  };
-  const mockKeyFilters: PreviewFilter = {
-    field: 'sub',
-    path: '$.payload.subreddit',
-  };
-  const mockContentFilters: PreviewFilter = {
-    field: 'author',
-    path: '$.payload.author',
-  };
-  const renderComponent = (
-    props: Partial<Props> = {
-      message: mockMessage,
-      keyFilters: [],
-      contentFilters: [],
-    }
-  ) =>
-    render(
-      <table>
-        <tbody>
-          <Message
-            message={props.message || mockMessage}
-            keyFilters={props.keyFilters || []}
-            contentFilters={props.contentFilters || []}
-          />
-        </tbody>
-      </table>
-    );
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockUseAppParams.mockReturnValue({
+      clusterName: 'test-cluster',
+      topicName: 'testTopic',
+    });
+  });
 
   it('shows the data in the table row', () => {
     renderComponent();
@@ -82,30 +95,43 @@ describe('Message component', () => {
     ).not.toBeInTheDocument();
   });
 
-  it('should check the dropdown being visible during hover', async () => {
+  it('should toggle action dropdown button visibility on hover', async () => {
     renderComponent();
-    const text = 'Save as a file';
     const trElement = screen.getByRole('row');
-    expect(screen.queryByText(text)).not.toBeInTheDocument();
 
-    await userEvent.hover(trElement);
-    expect(screen.getByText(text)).toBeInTheDocument();
+    expect(
+      screen.queryByRole('button', {
+        name: 'Dropdown Toggle',
+      })
+    ).not.toBeInTheDocument();
+
+    await act(() => userEvent.hover(trElement));
+
+    expect(
+      screen.getByRole('button', {
+        name: 'Dropdown Toggle',
+      })
+    ).toBeVisible();
 
-    await userEvent.unhover(trElement);
-    expect(screen.queryByText(text)).not.toBeInTheDocument();
+    await act(() => userEvent.unhover(trElement));
+    expect(
+      screen.queryByRole('button', {
+        name: 'Dropdown Toggle',
+      })
+    ).not.toBeInTheDocument();
   });
 
   it('should check open Message Content functionality', async () => {
     renderComponent();
     const messageToggleIcon = screen.getByRole('button', { hidden: true });
-    expect(screen.queryByText(messageContentText)).not.toBeInTheDocument();
-    await userEvent.click(messageToggleIcon);
-    expect(screen.getByText(messageContentText)).toBeInTheDocument();
+    expect(screen.queryByText(mockMessageContentText)).not.toBeInTheDocument();
+    await act(() => userEvent.click(messageToggleIcon));
+    expect(screen.getByText(mockMessageContentText)).toBeInTheDocument();
   });
 
   it('should check if Preview filter showing for key', () => {
     const props = {
-      message: { ...mockMessage, key: keyTest as string },
+      message: { ...mockMessage, key: mockMessageKey as string },
       keyFilters: [mockKeyFilters],
     };
     renderComponent(props);
@@ -115,11 +141,95 @@ describe('Message component', () => {
 
   it('should check if Preview filter showing for Value', () => {
     const props = {
-      message: { ...mockMessage, value: contentTest as string },
+      message: { ...mockMessage, value: mockMessageValue as string },
       contentFilters: [mockContentFilters],
     };
     renderComponent(props);
     const keyFiltered = screen.getByText('author: "DwaywelayTOP"');
     expect(keyFiltered).toBeInTheDocument();
   });
+
+  it('shows action options in dropdown on click', async () => {
+    renderComponent();
+    const trElement = screen.getByRole('row');
+
+    await act(() => userEvent.hover(trElement));
+
+    const dropdownToggle = screen.getByRole('button', {
+      name: 'Dropdown Toggle',
+    });
+    await act(() => userEvent.click(dropdownToggle));
+
+    expect(
+      await screen.findByRole('menuitem', { name: 'Copy to clipboard' })
+    ).toBeVisible();
+    expect(
+      await screen.findByRole('menuitem', { name: 'Save as a file' })
+    ).toBeVisible();
+    expect(
+      await screen.findByRole('menuitem', { name: 'Reproduce message' })
+    ).toBeVisible();
+  });
+
+  it('calls openSidebarWithMessage when "Produce Message" is clicked', async () => {
+    renderComponent(undefined, mockRoles);
+    const trElement = screen.getByRole('row');
+    await act(() => userEvent.hover(trElement));
+
+    const dropdownToggle = screen.getByRole('button', {
+      name: 'Dropdown Toggle',
+    });
+    await act(() => userEvent.click(dropdownToggle));
+
+    const produceMessageButton = screen.getByRole('menuitem', {
+      name: 'Reproduce message',
+    });
+    await act(() => userEvent.click(produceMessageButton));
+
+    expect(mockOpenSidebarWithMessage).toHaveBeenCalledTimes(1);
+    expect(mockOpenSidebarWithMessage).toHaveBeenCalledWith({
+      timestamp: mockMessage.timestamp,
+      timestampType: mockMessage.timestampType,
+      offset: mockMessage.offset,
+      key: mockMessage.key,
+      partition: mockMessage.partition,
+      value: mockMessage.value,
+      headers: mockMessage.headers,
+      valueSerde: mockMessage.valueSerde,
+      keySerde: mockMessage.keySerde,
+    });
+  });
+
+  test.each([
+    ['has produce message roles', true],
+    ['lacks produce message roles', false],
+  ])(
+    'when user %s for topic, "Reproduce message" button should be enabled: %s',
+    async (_scenario, hasRoles) => {
+      renderComponent(undefined, hasRoles ? mockRoles : mockNoRoles);
+
+      const trElement = screen.getByRole('row');
+      await act(() => userEvent.hover(trElement));
+
+      const dropdownToggle = screen.getByRole('button', {
+        name: 'Dropdown Toggle',
+      });
+      await act(() => userEvent.click(dropdownToggle));
+
+      const produceMessageButton = screen.getByRole('menuitem', {
+        name: 'Reproduce message',
+      });
+      await act(() => userEvent.hover(produceMessageButton));
+
+      if (hasRoles) {
+        expect(produceMessageButton).not.toHaveAttribute(
+          'aria-disabled',
+          'true'
+        );
+      } else {
+        expect(produceMessageButton).toHaveAttribute('aria-disabled', 'true');
+        expect(screen.getByText(getDefaultActionMessage())).toBeVisible();
+      }
+    }
+  );
 });
diff --git a/frontend/src/components/Topics/Topic/Messages/__test__/MessagesTable.spec.tsx b/frontend/src/components/Topics/Topic/Messages/__test__/MessagesTable.spec.tsx
index 7c91be5bd..bd4d09215 100644
--- a/frontend/src/components/Topics/Topic/Messages/__test__/MessagesTable.spec.tsx
+++ b/frontend/src/components/Topics/Topic/Messages/__test__/MessagesTable.spec.tsx
@@ -9,6 +9,7 @@ import { TopicMessage, TopicMessageTimestampTypeEnum } from 'generated-sources';
 import { useIsLiveMode } from 'lib/hooks/useMessagesFilters';
 import useAppParams from 'lib/hooks/useAppParams';
 import { LOCAL_STORAGE_KEY_PREFIX } from 'lib/constants';
+import { TopicActionsProvider } from 'components/contexts/TopicActionsContext';
 
 export const topicMessagePayload: TopicMessage = {
   partition: 29,
@@ -46,7 +47,9 @@ describe('MessagesTable', () => {
       topicName: 'testTopic',
     }));
     return render(
-      <MessagesTable messages={[]} isFetching={false} {...props} />
+      <TopicActionsProvider openSidebarWithMessage={jest.fn()}>
+        <MessagesTable messages={[]} isFetching={false} {...props} />
+      </TopicActionsProvider>
     );
   };
 
diff --git a/frontend/src/components/Topics/Topic/SendMessage/SendMessage.tsx b/frontend/src/components/Topics/Topic/SendMessage/SendMessage.tsx
index b820ebed3..20241efc6 100644
--- a/frontend/src/components/Topics/Topic/SendMessage/SendMessage.tsx
+++ b/frontend/src/components/Topics/Topic/SendMessage/SendMessage.tsx
@@ -11,6 +11,7 @@ import { useSendMessage, useTopicDetails } from 'lib/hooks/api/topics';
 import { InputLabel } from 'components/common/Input/InputLabel.styled';
 import { useSerdes } from 'lib/hooks/api/topicMessages';
 import { SerdeUsage } from 'generated-sources';
+import { MessageFormData } from 'lib/interfaces/message';
 
 import * as S from './SendMessage.styled';
 import {
@@ -20,18 +21,14 @@ import {
   validateBySchema,
 } from './utils';
 
-interface FormType {
-  key: string;
-  content: string;
-  headers: string;
-  partition: number;
-  keySerde: string;
-  valueSerde: string;
-  keepContents: boolean;
+interface SendMessageProps {
+  closeSidebar: () => void;
+  messageData?: Partial<MessageFormData> | null;
 }
 
-const SendMessage: React.FC<{ closeSidebar: () => void }> = ({
+const SendMessage: React.FC<SendMessageProps> = ({
   closeSidebar,
+  messageData = null,
 }) => {
   const { clusterName, topicName } = useAppParams<RouteParamsClusterTopic>();
   const { data: topic } = useTopicDetails({ clusterName, topicName });
@@ -41,24 +38,30 @@ const SendMessage: React.FC<{ closeSidebar: () => void }> = ({
     use: SerdeUsage.SERIALIZE,
   });
   const sendMessage = useSendMessage({ clusterName, topicName });
-
   const defaultValues = React.useMemo(() => getDefaultValues(serdes), [serdes]);
   const partitionOptions = React.useMemo(
     () => getPartitionOptions(topic?.partitions || []),
     [topic]
   );
+
+  const formDefaults = React.useMemo(
+    () => ({
+      ...defaultValues,
+      partition: Number(partitionOptions[0]?.value || 0),
+      keepContents: false,
+      ...messageData,
+    }),
+    [defaultValues, partitionOptions, messageData]
+  );
+
   const {
     handleSubmit,
     formState: { isSubmitting },
     control,
     setValue,
-  } = useForm<FormType>({
+  } = useForm<MessageFormData>({
     mode: 'onChange',
-    defaultValues: {
-      ...defaultValues,
-      partition: Number(partitionOptions[0].value),
-      keepContents: false,
-    },
+    defaultValues: formDefaults,
   });
 
   const submit = async ({
@@ -69,7 +72,7 @@ const SendMessage: React.FC<{ closeSidebar: () => void }> = ({
     headers,
     partition,
     keepContents,
-  }: FormType) => {
+  }: MessageFormData) => {
     let errors: string[] = [];
 
     if (keySerde) {
@@ -132,14 +135,14 @@ const SendMessage: React.FC<{ closeSidebar: () => void }> = ({
       <form onSubmit={handleSubmit(submit)}>
         <S.Columns>
           <S.FlexItem>
-            <InputLabel>Partition</InputLabel>
+            <InputLabel id="partitionOptionsLabel">Partition</InputLabel>
             <Controller
               control={control}
               name="partition"
               render={({ field: { name, onChange, value } }) => (
                 <Select
                   id="selectPartitionOptions"
-                  aria-labelledby="selectPartitionOptions"
+                  aria-labelledby="partitionOptionsLabel"
                   name={name}
                   onChange={onChange}
                   minWidth="100%"
@@ -151,14 +154,14 @@ const SendMessage: React.FC<{ closeSidebar: () => void }> = ({
           </S.FlexItem>
           <S.Flex>
             <S.FlexItem>
-              <InputLabel>Key Serde</InputLabel>
+              <InputLabel id="keySerdeOptionsLabel">Key Serde</InputLabel>
               <Controller
                 control={control}
                 name="keySerde"
                 render={({ field: { name, onChange, value } }) => (
                   <Select
                     id="selectKeySerdeOptions"
-                    aria-labelledby="selectKeySerdeOptions"
+                    aria-labelledby="keySerdeOptionsLabel"
                     name={name}
                     onChange={onChange}
                     minWidth="100%"
@@ -169,14 +172,14 @@ const SendMessage: React.FC<{ closeSidebar: () => void }> = ({
               />
             </S.FlexItem>
             <S.FlexItem>
-              <InputLabel>Value Serde</InputLabel>
+              <InputLabel id="valueSerdeOptionsLabel">Value Serde</InputLabel>
               <Controller
                 control={control}
                 name="valueSerde"
                 render={({ field: { name, onChange, value } }) => (
                   <Select
                     id="selectValueSerdeOptions"
-                    aria-labelledby="selectValueSerdeOptions"
+                    aria-labelledby="valueSerdeOptionsLabel"
                     name={name}
                     onChange={onChange}
                     minWidth="100%"
@@ -238,12 +241,12 @@ const SendMessage: React.FC<{ closeSidebar: () => void }> = ({
             <Controller
               control={control}
               name="headers"
-              render={({ field: { name, onChange } }) => (
+              render={({ field: { name, onChange, value } }) => (
                 <Editor
                   readOnly={isSubmitting}
-                  defaultValue="{}"
                   name={name}
                   onChange={onChange}
+                  value={value || '{}'}
                   height="40px"
                 />
               )}
diff --git a/frontend/src/components/Topics/Topic/SendMessage/__test__/SendMessage.spec.tsx b/frontend/src/components/Topics/Topic/SendMessage/__test__/SendMessage.spec.tsx
index 35137ef86..ad90fa513 100644
--- a/frontend/src/components/Topics/Topic/SendMessage/__test__/SendMessage.spec.tsx
+++ b/frontend/src/components/Topics/Topic/SendMessage/__test__/SendMessage.spec.tsx
@@ -5,10 +5,11 @@ import userEvent from '@testing-library/user-event';
 import { render, WithRoute } from 'lib/testHelpers';
 import { clusterTopicPath } from 'lib/paths';
 import { validateBySchema } from 'components/Topics/Topic/SendMessage/utils';
-import { externalTopicPayload } from 'lib/fixtures/topics';
+import { internalTopicPayload } from 'lib/fixtures/topics';
 import { useSendMessage, useTopicDetails } from 'lib/hooks/api/topics';
 import { useSerdes } from 'lib/hooks/api/topicMessages';
 import { serdesPayload } from 'lib/fixtures/topicMessages';
+import { MessageFormData } from 'lib/interfaces/message';
 
 import Mock = jest.Mock;
 
@@ -41,15 +42,50 @@ jest.mock('lib/hooks/api/topicMessages', () => ({
 }));
 
 const clusterName = 'testCluster';
-const topicName = externalTopicPayload.name;
+const topicPayloadMultiplePartitions = {
+  ...internalTopicPayload,
+  partitions: [
+    {
+      partition: 0,
+      leader: 1,
+      replicas: [{ broker: 1, leader: false, inSync: true }],
+      offsetMax: 0,
+      offsetMin: 0,
+    },
+    {
+      partition: 1,
+      leader: 1,
+      replicas: [{ broker: 1, leader: false, inSync: true }],
+      offsetMax: 0,
+      offsetMin: 0,
+    },
+    {
+      partition: 2,
+      leader: 1,
+      replicas: [{ broker: 1, leader: false, inSync: true }],
+      offsetMax: 3,
+      offsetMin: 0,
+    },
+    {
+      partition: 3,
+      leader: 1,
+      replicas: [{ broker: 1, leader: false, inSync: true }],
+      offsetMax: 0,
+      offsetMin: 0,
+    },
+  ],
+};
+const topicName = topicPayloadMultiplePartitions.name;
 
 const mockOnSubmit = jest.fn();
 
-const renderComponent = async () => {
+const renderComponent = async (
+  messageData?: Partial<MessageFormData> | null
+) => {
   const path = clusterTopicPath(clusterName, topicName);
-  await render(
+  render(
     <WithRoute path={clusterTopicPath()}>
-      <SendMessage closeSidebar={mockOnSubmit} />
+      <SendMessage closeSidebar={mockOnSubmit} messageData={messageData} />
     </WithRoute>,
     { initialEntries: [path] }
   );
@@ -70,31 +106,28 @@ const renderAndSubmitData = async (error: string[] = []) => {
 };
 
 describe('SendMessage', () => {
+  const sendTopicMessageMock = jest.fn();
   beforeEach(() => {
+    (useSendMessage as jest.Mock).mockImplementation(() => ({
+      mutateAsync: sendTopicMessageMock,
+    }));
     (useTopicDetails as jest.Mock).mockImplementation(() => ({
-      data: externalTopicPayload,
+      data: topicPayloadMultiplePartitions,
     }));
     (useSerdes as jest.Mock).mockImplementation(() => ({
       data: serdesPayload,
     }));
+    (validateBySchema as jest.Mock).mockImplementation(() => []);
   });
 
   describe('when schema is fetched', () => {
     it('calls sendTopicMessage on submit', async () => {
-      const sendTopicMessageMock = jest.fn();
-      (useSendMessage as jest.Mock).mockImplementation(() => ({
-        mutateAsync: sendTopicMessageMock,
-      }));
       await renderAndSubmitData();
       expect(sendTopicMessageMock).toHaveBeenCalledTimes(1);
       expect(mockOnSubmit).toHaveBeenCalledTimes(1);
     });
 
     it('should check and view validation error message when is not valid', async () => {
-      const sendTopicMessageMock = jest.fn();
-      (useSendMessage as jest.Mock).mockImplementation(() => ({
-        mutateAsync: sendTopicMessageMock,
-      }));
       await renderAndSubmitData(['error']);
       expect(sendTopicMessageMock).not.toHaveBeenCalled();
       expect(mockOnSubmit).not.toHaveBeenCalled();
@@ -107,4 +140,160 @@ describe('SendMessage', () => {
       expect(screen.getAllByRole('textbox')[0].nodeValue).toBeNull();
     });
   });
+
+  describe('when message data is provided', () => {
+    const messageData: MessageFormData = {
+      key: '123',
+      content: 'test-content',
+      headers: '{"header1": "value1"}',
+      partition: 3,
+      keySerde: 'Int32',
+      valueSerde: 'String',
+      keepContents: false,
+    };
+
+    it('should render form and produce message with prefilled values', async () => {
+      await renderComponent(messageData);
+
+      expect(
+        screen.getByRole('listbox', {
+          name: 'Partition',
+        })
+      ).toHaveTextContent('Partition #3');
+
+      expect(
+        screen.getByRole('listbox', {
+          name: 'Key Serde',
+        })
+      ).toHaveTextContent(messageData.keySerde);
+
+      expect(
+        screen.getByRole('listbox', {
+          name: 'Value Serde',
+        })
+      ).toHaveTextContent(messageData.valueSerde);
+
+      const submitButton = screen.getByRole('button', {
+        name: 'Produce Message',
+      });
+      await userEvent.click(submitButton);
+
+      expect(sendTopicMessageMock).toHaveBeenCalledTimes(1);
+      expect(sendTopicMessageMock).toHaveBeenCalledWith({
+        headers: { header1: 'value1' },
+        key: messageData.key,
+        keySerde: messageData.keySerde,
+        partition: messageData.partition,
+        value: messageData.content,
+        valueSerde: messageData.valueSerde,
+      });
+    });
+
+    it('should combine partial form data with default values', async () => {
+      const partialData: Partial<MessageFormData> = {
+        content: 'only-content',
+      };
+
+      await renderComponent(partialData);
+
+      const submitButton = screen.getByRole('button', {
+        name: 'Produce Message',
+      });
+      await userEvent.click(submitButton);
+
+      expect(sendTopicMessageMock).toHaveBeenCalledTimes(1);
+      expect(sendTopicMessageMock).toHaveBeenCalledWith({
+        headers: undefined,
+        key: '{"f1":-93251214,"schema":"enim sit in fugiat dolor","f2":"deserunt culpa sunt"}',
+        keySerde: 'Int32',
+        partition: 0,
+        value: partialData.content,
+        valueSerde: 'Int64',
+      });
+    });
+
+    it('should display correct partition in dropdown', async () => {
+      await renderComponent(messageData);
+
+      const partitionDropdown = screen.getByRole('listbox', {
+        name: 'Partition',
+      });
+      expect(partitionDropdown).toHaveTextContent('Partition #3');
+    });
+
+    it('should close sidebar after submitting', async () => {
+      (useSendMessage as jest.Mock).mockImplementation(() => ({
+        mutateAsync: sendTopicMessageMock,
+      }));
+
+      await renderComponent(messageData);
+
+      const submitButton = screen.getByRole('button', {
+        name: 'Produce Message',
+      });
+      await userEvent.click(submitButton);
+
+      await waitFor(() => {
+        expect(mockOnSubmit).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('when message data is null', () => {
+    it('should render form with default values', async () => {
+      await renderComponent();
+
+      expect(
+        screen.getByRole('listbox', {
+          name: 'Partition',
+        })
+      ).toHaveTextContent('Partition #0');
+
+      expect(
+        screen.getByRole('listbox', {
+          name: 'Key Serde',
+        })
+      ).toHaveTextContent('Int32');
+
+      expect(
+        screen.getByRole('listbox', {
+          name: 'Value Serde',
+        })
+      ).toHaveTextContent('Int64');
+
+      const submitButton = screen.getByRole('button', {
+        name: 'Produce Message',
+      });
+      await userEvent.click(submitButton);
+
+      expect(sendTopicMessageMock).toHaveBeenCalledTimes(1);
+      expect(sendTopicMessageMock).toHaveBeenCalledWith({
+        headers: undefined,
+        key: '{"f1":-93251214,"schema":"enim sit in fugiat dolor","f2":"deserunt culpa sunt"}',
+        keySerde: 'Int32',
+        partition: 0,
+        value:
+          '{"f1":-93251214,"schema":"enim sit in fugiat dolor","f2":"deserunt culpa sunt"}',
+        valueSerde: 'Int64',
+      });
+    });
+
+    it('should submit with empty form successfully', async () => {
+      (useSendMessage as jest.Mock).mockImplementation(() => ({
+        mutateAsync: sendTopicMessageMock,
+      }));
+
+      await renderComponent(null);
+
+      const submitButton = screen.getByRole('button', {
+        name: 'Produce Message',
+      });
+      await userEvent.click(submitButton);
+
+      await waitFor(() => {
+        expect(sendTopicMessageMock).toHaveBeenCalled();
+        expect(mockOnSubmit).toHaveBeenCalled();
+      });
+    });
+  });
 });
diff --git a/frontend/src/components/Topics/Topic/Topic.tsx b/frontend/src/components/Topics/Topic/Topic.tsx
index b0a89ed09..2840efe28 100644
--- a/frontend/src/components/Topics/Topic/Topic.tsx
+++ b/frontend/src/components/Topics/Topic/Topic.tsx
@@ -24,11 +24,18 @@ import {
   useRecreateTopic,
   useTopicDetails,
 } from 'lib/hooks/api/topics';
-import { Action, CleanUpPolicy, ResourceType } from 'generated-sources';
+import {
+  Action,
+  CleanUpPolicy,
+  ResourceType,
+  TopicMessage,
+} from 'generated-sources';
 import PageLoader from 'components/common/PageLoader/PageLoader';
 import SlidingSidebar from 'components/common/SlidingSidebar';
 import useBoolean from 'lib/hooks/useBoolean';
+import { useProduceMessage } from 'lib/hooks/useProduceMessage';
 import ResourcePageHeading from 'components/common/ResourcePageHeading/ResourcePageHeading';
+import { TopicActionsProvider } from 'components/contexts/TopicActionsContext';
 
 import Messages from './Messages/Messages';
 import Overview from './Overview/Overview';
@@ -44,8 +51,21 @@ const Topic: React.FC = () => {
     setFalse: closeSidebar,
     setTrue: openSidebar,
   } = useBoolean(false);
+
+  const { messageData, setMessage, clearMessage } = useProduceMessage();
+
   const { clusterName, topicName } = useAppParams<RouteParamsClusterTopic>();
 
+  const openSidebarWithMessage = (message: TopicMessage) => {
+    setMessage(message);
+    openSidebar();
+  };
+
+  const handleCloseSidebar = () => {
+    clearMessage();
+    closeSidebar();
+  };
+
   const navigate = useNavigate();
   const deleteTopic = useDeleteTopic(clusterName);
   const recreateTopic = useRecreateTopic({ clusterName, topicName });
@@ -206,35 +226,41 @@ const Topic: React.FC = () => {
           Statistics
         </ActionNavLink>
       </Navbar>
-      <Suspense fallback={<PageLoader />}>
-        <Routes>
-          <Route index element={<Overview />} />
-          <Route
-            path={clusterTopicMessagesRelativePath}
-            element={<Messages />}
-          />
-          <Route
-            path={clusterTopicSettingsRelativePath}
-            element={<Settings />}
-          />
-          <Route
-            path={clusterTopicConsumerGroupsRelativePath}
-            element={<TopicConsumerGroups />}
-          />
-          <Route
-            path={clusterTopicStatisticsRelativePath}
-            element={<Statistics />}
-          />
-          <Route path={clusterTopicEditRelativePath} element={<Edit />} />
-        </Routes>
-      </Suspense>
+      <TopicActionsProvider openSidebarWithMessage={openSidebarWithMessage}>
+        <Suspense fallback={<PageLoader />}>
+          <Routes>
+            <Route index element={<Overview />} />
+            <Route
+              path={clusterTopicMessagesRelativePath}
+              element={<Messages />}
+            />
+            <Route
+              path={clusterTopicSettingsRelativePath}
+              element={<Settings />}
+            />
+            <Route
+              path={clusterTopicConsumerGroupsRelativePath}
+              element={<TopicConsumerGroups />}
+            />
+            <Route
+              path={clusterTopicStatisticsRelativePath}
+              element={<Statistics />}
+            />
+            <Route path={clusterTopicEditRelativePath} element={<Edit />} />
+          </Routes>
+        </Suspense>
+      </TopicActionsProvider>
       <SlidingSidebar
         open={isSidebarOpen}
-        onClose={closeSidebar}
+        onClose={handleCloseSidebar}
         title="Produce Message"
       >
         <Suspense fallback={<PageLoader />}>
-          <SendMessage closeSidebar={closeSidebar} />
+          <SendMessage
+            key={messageData ? 'with-message' : 'empty'}
+            closeSidebar={closeSidebar}
+            messageData={messageData}
+          />
         </Suspense>
       </SlidingSidebar>
     </>
diff --git a/frontend/src/components/Topics/__tests__/Topics.spec.tsx b/frontend/src/components/Topics/__tests__/Topics.spec.tsx
index e4bc71942..536b640e0 100644
--- a/frontend/src/components/Topics/__tests__/Topics.spec.tsx
+++ b/frontend/src/components/Topics/__tests__/Topics.spec.tsx
@@ -40,7 +40,7 @@ describe('Topics Component', () => {
     expect(await screen.findByText(listContainer)).toBeInTheDocument();
   });
 
-  it('should check if the page is  New Topic  rendered', async () => {
+  it('should check if the page is New Topic rendered', async () => {
     setUpComponent(clusterTopicNewPath(clusterName));
     expect(await screen.findByText(newCopyContainer)).toBeInTheDocument();
   });
diff --git a/frontend/src/components/contexts/TopicActionsContext.tsx b/frontend/src/components/contexts/TopicActionsContext.tsx
new file mode 100644
index 000000000..8792b5d7b
--- /dev/null
+++ b/frontend/src/components/contexts/TopicActionsContext.tsx
@@ -0,0 +1,43 @@
+import React, { createContext, useContext, ReactNode } from 'react';
+import { TopicMessage } from 'generated-sources';
+
+interface TopicActionsContextValue {
+  openSidebarWithMessage: (message: TopicMessage) => void;
+}
+
+const TopicActionsContext = createContext<TopicActionsContextValue | null>(
+  null
+);
+
+interface TopicActionsProviderProps {
+  children: ReactNode;
+  openSidebarWithMessage: (message: TopicMessage) => void;
+}
+
+export const TopicActionsProvider: React.FC<TopicActionsProviderProps> = ({
+  children,
+  openSidebarWithMessage,
+}) => {
+  const value = React.useMemo(
+    () => ({
+      openSidebarWithMessage,
+    }),
+    [openSidebarWithMessage]
+  );
+
+  return (
+    <TopicActionsContext.Provider value={value}>
+      {children}
+    </TopicActionsContext.Provider>
+  );
+};
+
+export const useTopicActions = (): TopicActionsContextValue => {
+  const context = useContext(TopicActionsContext);
+  if (!context) {
+    throw new Error(
+      'useTopicActions must be used within a TopicActionsProvider'
+    );
+  }
+  return context;
+};
diff --git a/frontend/src/lib/hooks/__tests__/useProduceMessage.spec.ts b/frontend/src/lib/hooks/__tests__/useProduceMessage.spec.ts
new file mode 100644
index 000000000..9dab68cb4
--- /dev/null
+++ b/frontend/src/lib/hooks/__tests__/useProduceMessage.spec.ts
@@ -0,0 +1,88 @@
+import { renderHook, act } from '@testing-library/react';
+import { useProduceMessage } from 'lib/hooks/useProduceMessage';
+import { TopicMessage, TopicMessageTimestampTypeEnum } from 'generated-sources';
+
+describe('useProduceMessage', () => {
+  const mockMessage: TopicMessage = {
+    timestamp: new Date('2025-07-21T01:30:00Z'),
+    timestampType: TopicMessageTimestampTypeEnum.CREATE_TIME,
+    offset: 123,
+    key: 'test-key',
+    keySize: 8,
+    partition: 2,
+    value: 'test-value',
+    valueSize: 10,
+    headers: { header1: 'value1', header2: 'value2' },
+    valueSerde: 'String',
+    keySerde: 'String',
+  };
+
+  it('should initialize with null message data', () => {
+    const { result } = renderHook(() => useProduceMessage());
+    expect(result.current.messageData).toBeNull();
+  });
+
+  it('should convert message to message form data correctly', () => {
+    const { result } = renderHook(() => useProduceMessage());
+
+    act(() => {
+      result.current.setMessage(mockMessage);
+    });
+
+    expect(result.current.messageData).toEqual({
+      content: 'test-value',
+      keepContents: false,
+      key: 'test-key',
+      headers: '{\n  "header1": "value1",\n  "header2": "value2"\n}',
+      partition: 2,
+      valueSerde: 'String',
+      keySerde: 'String',
+    });
+  });
+
+  it('should handle message with empty headers', () => {
+    const { result } = renderHook(() => useProduceMessage());
+    const messageWithEmptyHeaders = { ...mockMessage, headers: {} };
+
+    act(() => {
+      result.current.setMessage(messageWithEmptyHeaders);
+    });
+
+    expect(result.current.messageData).not.toHaveProperty('headers');
+  });
+
+  it('should handle message with missing optional fields', () => {
+    const { result } = renderHook(() => useProduceMessage());
+    const minimalMessage: TopicMessage = {
+      timestamp: new Date('2025-07-20T10:00:00Z'),
+      timestampType: TopicMessageTimestampTypeEnum.CREATE_TIME,
+      offset: 123,
+      partition: 0,
+      value: 'value',
+    };
+
+    act(() => {
+      result.current.setMessage(minimalMessage);
+    });
+
+    expect(result.current.messageData).toEqual({
+      keepContents: false,
+      content: 'value',
+      partition: 0,
+    });
+  });
+
+  it('should clear message on callback', () => {
+    const { result } = renderHook(() => useProduceMessage());
+
+    act(() => {
+      result.current.setMessage(mockMessage);
+    });
+    expect(result.current.messageData).not.toBeNull();
+
+    act(() => {
+      result.current.clearMessage();
+    });
+    expect(result.current.messageData).toBeNull();
+  });
+});
diff --git a/frontend/src/lib/hooks/useProduceMessage.ts b/frontend/src/lib/hooks/useProduceMessage.ts
new file mode 100644
index 000000000..b2f7ed5be
--- /dev/null
+++ b/frontend/src/lib/hooks/useProduceMessage.ts
@@ -0,0 +1,53 @@
+import { useState, useCallback } from 'react';
+import { TopicMessage } from 'generated-sources';
+import { MessageFormData } from 'lib/interfaces/message';
+
+interface UseProduceMessageReturn {
+  messageData: Partial<MessageFormData> | null;
+  setMessage: (message: TopicMessage) => void;
+  clearMessage: () => void;
+}
+
+export const useProduceMessage = (): UseProduceMessageReturn => {
+  const [messageData, setMessageData] =
+    useState<Partial<MessageFormData> | null>(null);
+
+  const setMessage = useCallback((message: TopicMessage) => {
+    const data: Partial<MessageFormData> = {
+      keepContents: false,
+      content: message.value || '',
+    };
+
+    if (message.key) {
+      data.key = message.key;
+    }
+
+    if (message.headers && Object.keys(message.headers).length > 0) {
+      data.headers = JSON.stringify(message.headers, null, 2);
+    }
+
+    if (message.partition !== undefined) {
+      data.partition = message.partition;
+    }
+
+    if (message.valueSerde) {
+      data.valueSerde = message.valueSerde;
+    }
+
+    if (message.keySerde) {
+      data.keySerde = message.keySerde;
+    }
+
+    setMessageData(data);
+  }, []);
+
+  const clearMessage = useCallback(() => {
+    setMessageData(null);
+  }, []);
+
+  return {
+    messageData,
+    setMessage,
+    clearMessage,
+  };
+};
diff --git a/frontend/src/lib/interfaces/message.ts b/frontend/src/lib/interfaces/message.ts
new file mode 100644
index 000000000..d4dc849bf
--- /dev/null
+++ b/frontend/src/lib/interfaces/message.ts
@@ -0,0 +1,9 @@
+export interface MessageFormData {
+  key: string;
+  content: string;
+  headers: string;
+  partition: number;
+  keySerde: string;
+  valueSerde: string;
+  keepContents: boolean;
+}