diff --git a/.changeset/orange-gifts-protect.md b/.changeset/orange-gifts-protect.md
new file mode 100644
index 0000000000..1de9e2a6ba
--- /dev/null
+++ b/.changeset/orange-gifts-protect.md
@@ -0,0 +1,5 @@
+---
+'@backstage/plugin-scaffolder-backend-module-bitbucket-server': patch
+---
+
+Added examples for publish:bitbucketServer action and improve its test cases
diff --git a/plugins/scaffolder-backend-module-bitbucket-server/src/actions/bitbucketServer.examples.test.ts b/plugins/scaffolder-backend-module-bitbucket-server/src/actions/bitbucketServer.examples.test.ts
index 101379d1e6..8e222a6876 100644
--- a/plugins/scaffolder-backend-module-bitbucket-server/src/actions/bitbucketServer.examples.test.ts
+++ b/plugins/scaffolder-backend-module-bitbucket-server/src/actions/bitbucketServer.examples.test.ts
@@ -34,7 +34,10 @@ import { ScmIntegrations } from '@backstage/integration';
 import { ConfigReader } from '@backstage/config';
 import yaml from 'yaml';
 import { examples } from './bitbucketServer.examples';
-import { initRepoAndPush } from '@backstage/plugin-scaffolder-node';
+import {
+  getRepoSourceDirectory,
+  initRepoAndPush,
+} from '@backstage/plugin-scaffolder-node';
 import { createMockActionContext } from '@backstage/plugin-scaffolder-node-test-utils';
 
 describe('publish:bitbucketServer', () => {
@@ -266,7 +269,8 @@ describe('publish:bitbucketServer', () => {
 
   it(`should ${examples[3].description}`, async () => {
     expect.assertions(3);
-    server.use(
+
+    const handlers = [
       rest.post(
         'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
         (req, res, ctx) => {
@@ -300,7 +304,35 @@ describe('publish:bitbucketServer', () => {
           );
         },
       ),
-    );
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
 
     await action.handler({
       ...mockContext,
@@ -334,7 +366,8 @@ describe('publish:bitbucketServer', () => {
 
   it(`should ${examples[4].description}`, async () => {
     expect.assertions(3);
-    server.use(
+
+    const handlers = [
       rest.post(
         'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
         (req, res, ctx) => {
@@ -368,7 +401,35 @@ describe('publish:bitbucketServer', () => {
           );
         },
       ),
-    );
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
 
     await action.handler({
       ...mockContext,
@@ -399,4 +460,1050 @@ describe('publish:bitbucketServer', () => {
       gitAuthorInfo: { name: 'Test User', email: 'test.user@example.com' },
     });
   });
+  it(`should ${examples[5].description}`, async () => {
+    expect.assertions(3);
+
+    const handlers = [
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe(`Bearer thing`);
+          expect(req.body).toEqual({
+            public: false,
+            name: 'repo',
+            defaultBranch: 'master',
+          });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
+
+    let input;
+    try {
+      input = yaml.parse(examples[5].example).steps[0].input;
+    } catch (error) {
+      console.error('Failed to parse YAML:', error);
+    }
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        ...input,
+      },
+    });
+
+    // Ensure that the initRepoAndPush function was called with the correct remoteUrl and input properties
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      defaultBranch: 'master',
+      auth: { token: 'thing' },
+      logger: mockContext.logger,
+      commitMessage: 'initial commit',
+      gitAuthorInfo: {
+        name: 'Custom Author',
+        email: 'custom.author@example.com',
+      },
+    });
+  });
+
+  it(`should ${examples[6].description}`, async () => {
+    expect.assertions(5);
+
+    const handlers = [
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({
+            public: false,
+            name: 'repo',
+            defaultBranch: 'master',
+          });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                  {
+                    href: 'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
+
+    let input;
+    try {
+      input = yaml.parse(examples[6].example).steps[0].input;
+    } catch (error) {
+      console.error('Failed to parse YAML:', error);
+    }
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        ...input,
+      },
+    });
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      defaultBranch: 'master',
+      auth: { token: 'thing' },
+      logger: mockContext.logger,
+      commitMessage: 'Initial commit with LFS enabled',
+      gitAuthorInfo: {
+        email: input.gitAuthorName,
+        name: input.gitAuthorEmail,
+      },
+    });
+  });
+
+  it(`should ${examples[7].description}`, async () => {
+    expect.assertions(3);
+
+    const handlers = [
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer custom-token');
+          expect(req.body).toEqual({
+            public: false,
+            name: 'repo',
+            defaultBranch: 'master',
+          });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                  {
+                    href: 'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
+
+    let input;
+    try {
+      input = yaml.parse(examples[7].example).steps[0].input;
+    } catch (error) {
+      console.error('Failed to parse YAML:', error);
+    }
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        ...input,
+      },
+    });
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: getRepoSourceDirectory(mockContext.workspacePath, input.sourcePath),
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      auth: { token: 'custom-token' },
+      defaultBranch: 'master',
+      logger: mockContext.logger,
+      commitMessage: 'initial commit',
+      gitAuthorInfo: { name: undefined, email: undefined },
+    });
+  });
+
+  it(`should ${examples[8].description}`, async () => {
+    expect.assertions(3);
+
+    const handlers = [
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({
+            public: false,
+            name: 'repo',
+            defaultBranch: 'master',
+          });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                  {
+                    href: 'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
+
+    let input;
+    try {
+      input = yaml.parse(examples[8].example).steps[0].input;
+    } catch (error) {
+      console.error('Failed to parse YAML:', error);
+    }
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        ...input,
+      },
+    });
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      auth: { token: 'thing' },
+      defaultBranch: 'master',
+      logger: mockContext.logger,
+      commitMessage: 'initial commit',
+      gitAuthorInfo: { name: input.gitAuthorName, email: input.gitAuthorEmail },
+    });
+  });
+
+  it(`should ${examples[9].description}`, async () => {
+    expect.assertions(3);
+
+    const handlers = [
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({
+            public: true,
+            name: 'repo',
+            defaultBranch: 'master',
+          });
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                  {
+                    href: 'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
+
+    let input;
+    try {
+      input = yaml.parse(examples[9].example).steps[0].input;
+    } catch (error) {
+      console.error('Failed to parse YAML:', error);
+    }
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        ...input,
+      },
+    });
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      auth: { token: 'thing' },
+      defaultBranch: 'master',
+      logger: mockContext.logger,
+      commitMessage: 'Public repository initial commit',
+      gitAuthorInfo: { name: input.gitAuthorName, email: input.gitAuthorEmail },
+    });
+  });
+
+  it(`should ${examples[10].description}`, async () => {
+    expect.assertions(5);
+
+    const handlers = [
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer custom-token');
+          expect(req.body).toEqual({
+            public: false,
+            name: 'repo',
+            description: 'A fully customized repository',
+            defaultBranch: 'development',
+          });
+
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                  {
+                    href: 'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer custom-token');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
+
+    let input;
+    try {
+      input = yaml.parse(examples[10].example).steps[0].input;
+    } catch (error) {
+      console.error('Failed to parse YAML:', error);
+    }
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        ...input,
+      },
+    });
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: getRepoSourceDirectory(mockContext.workspacePath, input.sourcePath),
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      auth: { token: input.token },
+      defaultBranch: input.defaultBranch,
+      logger: mockContext.logger,
+      commitMessage: input.gitCommitMessage,
+      gitAuthorInfo: { name: input.gitAuthorName, email: input.gitAuthorEmail },
+    });
+  });
+
+  it(`should ${examples[11].description}`, async () => {
+    expect.assertions(3);
+
+    const handlers = [
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({
+            public: false,
+            name: 'repo',
+            defaultBranch: 'main',
+          });
+
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                  {
+                    href: 'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer custom-token');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
+
+    let input;
+    try {
+      input = yaml.parse(examples[11].example).steps[0].input;
+    } catch (error) {
+      console.error('Failed to parse YAML:', error);
+    }
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        ...input,
+      },
+    });
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: input.sourcePath
+        ? getRepoSourceDirectory(mockContext.workspacePath, input.sourcePath)
+        : mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      auth: { token: input.token ?? 'thing' },
+      defaultBranch: input.defaultBranch,
+      logger: mockContext.logger,
+      commitMessage: input.gitCommitMessage ?? 'initial commit',
+      gitAuthorInfo: { name: input.gitAuthorName, email: input.gitAuthorEmail },
+    });
+  });
+
+  it(`should ${examples[12].description}`, async () => {
+    expect.assertions(3);
+
+    const handlers = [
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({
+            public: true,
+            name: 'repo',
+            defaultBranch: 'master',
+            description: 'A public repository with a custom description',
+          });
+
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                  {
+                    href: 'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer custom-token');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
+
+    let input;
+    try {
+      input = yaml.parse(examples[12].example).steps[0].input;
+    } catch (error) {
+      console.error('Failed to parse YAML:', error);
+    }
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        ...input,
+      },
+    });
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: input.sourcePath
+        ? getRepoSourceDirectory(mockContext.workspacePath, input.sourcePath)
+        : mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      auth: { token: input.token ?? 'thing' },
+      defaultBranch: input.defaultBranch ?? 'master',
+      logger: mockContext.logger,
+      commitMessage: input.gitCommitMessage ?? 'initial commit',
+      gitAuthorInfo: { name: input.gitAuthorName, email: input.gitAuthorEmail },
+    });
+  });
+
+  it(`should ${examples[13].description}`, async () => {
+    expect.assertions(3);
+
+    const handlers = [
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe(
+            'Bearer custom-auth-token',
+          );
+          expect(req.body).toEqual({
+            public: false,
+            name: 'repo',
+            defaultBranch: 'master',
+          });
+
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                  {
+                    href: 'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer custom-token');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
+
+    let input;
+    try {
+      input = yaml.parse(examples[13].example).steps[0].input;
+    } catch (error) {
+      console.error('Failed to parse YAML:', error);
+    }
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        ...input,
+      },
+    });
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: input.sourcePath
+        ? getRepoSourceDirectory(mockContext.workspacePath, input.sourcePath)
+        : mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      auth: { token: input.token ?? 'thing' },
+      defaultBranch: input.defaultBranch ?? 'master',
+      logger: mockContext.logger,
+      commitMessage: input.gitCommitMessage ?? 'initial commit',
+      gitAuthorInfo: { name: input.gitAuthorName, email: input.gitAuthorEmail },
+    });
+  });
+
+  it(`should ${examples[14].description}`, async () => {
+    expect.assertions(3);
+
+    const handlers = [
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({
+            public: false,
+            name: 'repo',
+            defaultBranch: 'master',
+          });
+
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                  {
+                    href: 'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer custom-token');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
+
+    let input;
+    try {
+      input = yaml.parse(examples[14].example).steps[0].input;
+    } catch (error) {
+      console.error('Failed to parse YAML:', error);
+    }
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        ...input,
+      },
+    });
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: input.sourcePath
+        ? getRepoSourceDirectory(mockContext.workspacePath, input.sourcePath)
+        : mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      auth: { token: input.token ?? 'thing' },
+      defaultBranch: input.defaultBranch ?? 'master',
+      logger: mockContext.logger,
+      commitMessage: input.gitCommitMessage ?? 'initial commit',
+      gitAuthorInfo: { name: input.gitAuthorName, email: input.gitAuthorEmail },
+    });
+  });
+
+  it(`should ${examples[15].description}`, async () => {
+    expect.assertions(5);
+
+    const handlers = [
+      rest.post(
+        'https://hosted.bitbucket.com/rest/api/1.0/projects/project/repos',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual({
+            public: false,
+            name: 'repo',
+            defaultBranch: 'master',
+          });
+
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                  {
+                    href: 'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+      rest.put(
+        'https://hosted.bitbucket.com/rest/git-lfs/admin/projects/project/repos/repo/enabled',
+        (req, res, ctx) => {
+          expect(req.headers.get('Authorization')).toBe('Bearer thing');
+          expect(req.body).toEqual('');
+          return res(
+            ctx.status(201),
+            ctx.set('Content-Type', 'application/json'),
+            ctx.json({
+              links: {
+                self: [
+                  {
+                    href: 'https://bitbucket.mycompany.com/projects/project/repos/repo',
+                  },
+                ],
+                clone: [
+                  {
+                    name: 'http',
+                    href: 'https://bitbucket.mycompany.com/scm/project/repo',
+                  },
+                ],
+              },
+            }),
+          );
+        },
+      ),
+    ];
+
+    server.use(...handlers);
+
+    let input;
+    try {
+      input = yaml.parse(examples[15].example).steps[0].input;
+    } catch (error) {
+      console.error('Failed to parse YAML:', error);
+    }
+
+    await action.handler({
+      ...mockContext,
+      input: {
+        ...mockContext.input,
+        ...input,
+      },
+    });
+
+    expect(initRepoAndPush).toHaveBeenCalledWith({
+      dir: input.sourcePath
+        ? getRepoSourceDirectory(mockContext.workspacePath, input.sourcePath)
+        : mockContext.workspacePath,
+      remoteUrl: 'https://bitbucket.mycompany.com/scm/project/repo',
+      auth: { token: input.token ?? 'thing' },
+      defaultBranch: input.defaultBranch ?? 'master',
+      logger: mockContext.logger,
+      commitMessage: input.gitCommitMessage ?? 'initial commit',
+      gitAuthorInfo: { name: input.gitAuthorName, email: input.gitAuthorEmail },
+    });
+  });
 });
diff --git a/plugins/scaffolder-backend-module-bitbucket-server/src/actions/bitbucketServer.examples.ts b/plugins/scaffolder-backend-module-bitbucket-server/src/actions/bitbucketServer.examples.ts
index b3a68eed57..e28f9ca48c 100644
--- a/plugins/scaffolder-backend-module-bitbucket-server/src/actions/bitbucketServer.examples.ts
+++ b/plugins/scaffolder-backend-module-bitbucket-server/src/actions/bitbucketServer.examples.ts
@@ -129,4 +129,207 @@ export const examples: TemplateExample[] = [
       ],
     }),
   },
+  {
+    description:
+      'Initialize git repository with default settings and custom author information',
+    example: yaml.stringify({
+      steps: [
+        {
+          action: 'publish:bitbucketServer',
+          id: 'publish-bitbucket-server-custom-author',
+          name: 'Publish To Bitbucket Server',
+          input: {
+            repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+            gitAuthorName: 'Custom Author',
+            gitAuthorEmail: 'custom.author@example.com',
+          },
+        },
+      ],
+    }),
+  },
+  {
+    description:
+      'Initialize git repository with LFS enabled and a specific commit message',
+    example: yaml.stringify({
+      steps: [
+        {
+          action: 'publish:bitbucketServer',
+          id: 'publish-bitbucket-server-lfs-commit',
+          name: 'Publish To Bitbucket Server',
+          input: {
+            repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+            enableLFS: true,
+            gitCommitMessage: 'Initial commit with LFS enabled',
+          },
+        },
+      ],
+    }),
+  },
+  {
+    description:
+      'Initialize git repository with a custom source path and token',
+    example: yaml.stringify({
+      steps: [
+        {
+          action: 'publish:bitbucketServer',
+          id: 'publish-bitbucket-server-custom-source',
+          name: 'Publish To Bitbucket Server',
+          input: {
+            repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+            sourcePath: 'custom/source/path',
+            token: 'custom-token',
+          },
+        },
+      ],
+    }),
+  },
+  {
+    description:
+      'Initialize git repository with private visibility and custom author details',
+    example: yaml.stringify({
+      steps: [
+        {
+          action: 'publish:bitbucketServer',
+          id: 'publish-bitbucket-server-private-custom-author',
+          name: 'Publish To Bitbucket Server',
+          input: {
+            repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+            repoVisibility: 'private',
+            gitAuthorName: 'Private Author',
+            gitAuthorEmail: 'private.author@example.com',
+          },
+        },
+      ],
+    }),
+  },
+  {
+    description:
+      'Initialize git repository with public visibility and specific commit message',
+    example: yaml.stringify({
+      steps: [
+        {
+          action: 'publish:bitbucketServer',
+          id: 'publish-bitbucket-server-public-commit',
+          name: 'Publish To Bitbucket Server',
+          input: {
+            repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+            repoVisibility: 'public',
+            gitCommitMessage: 'Public repository initial commit',
+          },
+        },
+      ],
+    }),
+  },
+  {
+    description: 'Initialize git repository with all settings customized',
+    example: yaml.stringify({
+      steps: [
+        {
+          action: 'publish:bitbucketServer',
+          id: 'publish-bitbucket-server-all-custom',
+          name: 'Publish To Bitbucket Server',
+          input: {
+            repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+            description: 'A fully customized repository',
+            repoVisibility: 'private',
+            defaultBranch: 'development',
+            sourcePath: 'src/backend',
+            enableLFS: true,
+            token: 'custom-token',
+            gitCommitMessage: 'Fully customized initial commit',
+            gitAuthorName: 'Custom Dev',
+            gitAuthorEmail: 'custom.dev@example.com',
+          },
+        },
+      ],
+    }),
+  },
+  {
+    description:
+      'Initialize git repository with a specific default branch and no LFS',
+    example: yaml.stringify({
+      steps: [
+        {
+          action: 'publish:bitbucketServer',
+          id: 'publish-bitbucket-server-no-lfs',
+          name: 'Publish To Bitbucket Server',
+          input: {
+            repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+            defaultBranch: 'main',
+            enableLFS: false,
+          },
+        },
+      ],
+    }),
+  },
+  {
+    description:
+      'Initialize git repository with a custom repository description and public visibility',
+    example: yaml.stringify({
+      steps: [
+        {
+          action: 'publish:bitbucketServer',
+          id: 'publish-bitbucket-server-custom-description',
+          name: 'Publish To Bitbucket Server',
+          input: {
+            repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+            description: 'A public repository with a custom description',
+            repoVisibility: 'public',
+          },
+        },
+      ],
+    }),
+  },
+  {
+    description:
+      'Initialize git repository with a custom token for authentication',
+    example: yaml.stringify({
+      steps: [
+        {
+          action: 'publish:bitbucketServer',
+          id: 'publish-bitbucket-server-custom-token',
+          name: 'Publish To Bitbucket Server',
+          input: {
+            repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+            token: 'custom-auth-token',
+          },
+        },
+      ],
+    }),
+  },
+  {
+    description:
+      'Initialize git repository with a different repository root path',
+    example: yaml.stringify({
+      steps: [
+        {
+          action: 'publish:bitbucketServer',
+          id: 'publish-bitbucket-server-different-root',
+          name: 'Publish To Bitbucket Server',
+          input: {
+            repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+            sourcePath: 'different/root/path',
+          },
+        },
+      ],
+    }),
+  },
+  {
+    description:
+      'Initialize git repository with private visibility and LFS enabled',
+    example: yaml.stringify({
+      steps: [
+        {
+          action: 'publish:bitbucketServer',
+          id: 'publish-bitbucket-server-private-lfs',
+          name: 'Publish To Bitbucket Server',
+          input: {
+            repoUrl: 'hosted.bitbucket.com?project=project&repo=repo',
+            repoVisibility: 'private',
+            enableLFS: true,
+          },
+        },
+      ],
+    }),
+  },
 ];