diff --git a/core-web/libs/data-access/src/lib/dot-languages/dot-languages.service.spec.ts b/core-web/libs/data-access/src/lib/dot-languages/dot-languages.service.spec.ts
index 96c4c1006008..32f6a3d2e840 100644
--- a/core-web/libs/data-access/src/lib/dot-languages/dot-languages.service.spec.ts
+++ b/core-web/libs/data-access/src/lib/dot-languages/dot-languages.service.spec.ts
@@ -1,6 +1,11 @@
 import { createHttpFactory, HttpMethod, SpectatorHttp } from '@ngneat/spectator/jest';
 
-import { DotLanguagesService } from '@dotcms/data-access';
+import {
+    DotLanguagesService,
+    LANGUAGE_API_URL,
+    LANGUAGE_API_URL_WITH_VARS
+} from '@dotcms/data-access';
+import { DotLanguage } from '@dotcms/dotcms-models';
 
 describe('DotLanguagesService', () => {
     let spectator: SpectatorHttp<DotLanguagesService>;
@@ -10,13 +15,16 @@ describe('DotLanguagesService', () => {
 
     it('should get Languages', () => {
         spectator.service.get().subscribe();
-        spectator.expectOne(`/api/v2/languages`, HttpMethod.GET);
+        spectator.expectOne(LANGUAGE_API_URL_WITH_VARS, HttpMethod.GET);
     });
 
     it('should get Languages by content indode', () => {
         const contentInode = '2';
         spectator.service.get(contentInode).subscribe();
-        spectator.expectOne(`/api/v2/languages?contentInode=${contentInode}`, HttpMethod.GET);
+        spectator.expectOne(
+            `${LANGUAGE_API_URL_WITH_VARS}&contentInode=${contentInode}`,
+            HttpMethod.GET
+        );
     });
 
     it('should get Languages by pageId', () => {
@@ -24,4 +32,48 @@ describe('DotLanguagesService', () => {
         spectator.service.getLanguagesUsedPage(pageIdentifier).subscribe();
         spectator.expectOne(`/api/v1/page/${pageIdentifier}/languages`, HttpMethod.GET);
     });
+
+    it('should add a new language', () => {
+        const language = {
+            languageCode: 'fr',
+            countryCode: 'FR',
+            language: 'French',
+            country: 'France'
+        };
+        spectator.service.add(language).subscribe();
+        const req = spectator.expectOne(LANGUAGE_API_URL, HttpMethod.POST);
+        expect(req.request.body).toEqual(language);
+    });
+
+    it('should get a language by id', () => {
+        const id = 1;
+        spectator.service.getById(id).subscribe();
+        spectator.expectOne(`${LANGUAGE_API_URL}/id/${id}`, HttpMethod.GET);
+    });
+
+    it('should update a language', () => {
+        const language = {
+            id: '1',
+            languageCode: 'fr'
+        } as unknown as DotLanguage;
+        spectator.service.update(language).subscribe();
+        spectator.expectOne(`${LANGUAGE_API_URL}/${language.id}`, HttpMethod.PUT);
+    });
+
+    it('should delete a language by id', () => {
+        const id = 1;
+        spectator.service.delete(id).subscribe();
+        spectator.expectOne(`${LANGUAGE_API_URL}/${id}`, HttpMethod.DELETE);
+    });
+
+    it('should make a language the default language', () => {
+        const id = 1;
+        spectator.service.makeDefault(id).subscribe();
+        spectator.expectOne(`${LANGUAGE_API_URL}/${id}/_makedefault`, HttpMethod.PUT);
+    });
+
+    it('should get languages and countries in ISO format', () => {
+        spectator.service.getISO().subscribe();
+        spectator.expectOne(`${LANGUAGE_API_URL}/iso`, HttpMethod.GET);
+    });
 });
diff --git a/core-web/libs/data-access/src/lib/dot-languages/dot-languages.service.ts b/core-web/libs/data-access/src/lib/dot-languages/dot-languages.service.ts
index 77ba037f8b37..db337b7bebe2 100644
--- a/core-web/libs/data-access/src/lib/dot-languages/dot-languages.service.ts
+++ b/core-web/libs/data-access/src/lib/dot-languages/dot-languages.service.ts
@@ -5,7 +5,11 @@ import { inject, Injectable } from '@angular/core';
 
 import { pluck } from 'rxjs/operators';
 
-import { DotLanguage } from '@dotcms/dotcms-models';
+import { DotAddLanguage, DotLanguage, DotLanguagesISO } from '@dotcms/dotcms-models';
+
+export const LANGUAGE_API_URL = '/api/v2/languages';
+
+export const LANGUAGE_API_URL_WITH_VARS = '/api/v2/languages?countLangVars=true';
 
 /**
  * Provide util methods to get Languages available in the system.
@@ -23,8 +27,8 @@ export class DotLanguagesService {
      */
     get(contentInode?: string): Observable<DotLanguage[]> {
         const url = !contentInode
-            ? '/api/v2/languages'
-            : `/api/v2/languages?contentInode=${contentInode}`;
+            ? LANGUAGE_API_URL_WITH_VARS
+            : `${LANGUAGE_API_URL_WITH_VARS}&contentInode=${contentInode}`;
 
         return this.httpClient.get(url).pipe(pluck('entity'));
     }
@@ -40,4 +44,62 @@ export class DotLanguagesService {
             .get(`/api/v1/page/${pageIdentifier}/languages`)
             .pipe(pluck('entity'));
     }
+
+    /**
+     * Add a new language to the system.
+     *
+     * @param {DotAddLanguage} language - The language to be added.
+     * @return {Observable<DotLanguage>} An observable of the language added.
+     */
+    add(language: DotAddLanguage): Observable<DotLanguage> {
+        return this.httpClient.post(LANGUAGE_API_URL, language).pipe(pluck('entity'));
+    }
+
+    /**
+     * Get Language by id.
+     *
+     * @param {number} id
+     * @return {Observable<DotLanguage>}
+     */
+    getById(id: number): Observable<DotLanguage> {
+        return this.httpClient.get(`${LANGUAGE_API_URL}/id/${id}`).pipe(pluck('entity'));
+    }
+
+    /**
+     * Update a language.
+     *
+     * @param {DotLanguage} language - The language to be updated.
+     * @return {Observable<DotLanguage>} An observable of the updated language.
+     */
+    update(language: DotLanguage): Observable<DotLanguage> {
+        return this.httpClient
+            .put(`${LANGUAGE_API_URL}/${language.id}`, language)
+            .pipe(pluck('entity'));
+    }
+
+    /**
+     * Delete a language.
+     *
+     * @param {string} id -
+     * @return {Observable<void>}
+     */
+    delete(id: number): Observable<void> {
+        return this.httpClient.delete(`${LANGUAGE_API_URL}/${id}`).pipe(pluck('entity'));
+    }
+
+    /**
+     * Make a language the default language.
+     *
+     * @param {number} id - The identifier of the language to be made the default.
+     * @return {Observable<void>}
+     */
+    makeDefault(id: number): Observable<void> {
+        return this.httpClient
+            .put(`${LANGUAGE_API_URL}/${id}/_makedefault`, {})
+            .pipe(pluck('entity'));
+    }
+
+    getISO(): Observable<DotLanguagesISO> {
+        return this.httpClient.get(`${LANGUAGE_API_URL}/iso`).pipe(pluck('entity'));
+    }
 }
diff --git a/core-web/libs/dotcms-models/src/lib/dot-language.model.ts b/core-web/libs/dotcms-models/src/lib/dot-language.model.ts
index 8f5c4ad3efd1..9f08e6d4efce 100644
--- a/core-web/libs/dotcms-models/src/lib/dot-language.model.ts
+++ b/core-web/libs/dotcms-models/src/lib/dot-language.model.ts
@@ -1,10 +1,24 @@
-export interface DotLanguage {
-    id: number;
-    languageCode: string;
+export interface DotAddLanguage {
+    country: string;
     countryCode: string;
     language: string;
-    country: string;
+    languageCode: string;
+}
+
+export interface DotLanguage extends DotAddLanguage {
+    id: number;
     defaultLanguage?: boolean;
     translated?: boolean;
     isoCode?: string;
+    variables?: { count: number; total: number };
+}
+
+export interface DotISOItem {
+    code: string;
+    name: string;
+}
+
+export interface DotLanguagesISO {
+    countries: DotISOItem[];
+    languages: DotISOItem[];
 }
diff --git a/core-web/libs/portlets/dot-locales/data-access/src/index.ts b/core-web/libs/portlets/dot-locales/data-access/src/index.ts
index eb7235986dd8..e69de29bb2d1 100644
--- a/core-web/libs/portlets/dot-locales/data-access/src/index.ts
+++ b/core-web/libs/portlets/dot-locales/data-access/src/index.ts
@@ -1 +0,0 @@
-export * from './lib/resolvers/dot-locales-list.resolver';
diff --git a/core-web/libs/portlets/dot-locales/data-access/src/lib/resolvers/dot-locales-list.resolver.spec.ts b/core-web/libs/portlets/dot-locales/data-access/src/lib/resolvers/dot-locales-list.resolver.spec.ts
deleted file mode 100644
index 4f3fbad9f0aa..000000000000
--- a/core-web/libs/portlets/dot-locales/data-access/src/lib/resolvers/dot-locales-list.resolver.spec.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import { Observable, of } from 'rxjs';
-
-import { EnvironmentInjector, runInInjectionContext } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-
-import { DotLanguagesService } from '@dotcms/data-access';
-import { DotLanguage } from '@dotcms/dotcms-models';
-
-import { DotLocalesListResolver } from './dot-locales-list.resolver';
-
-const mockLanguages: DotLanguage[] = [
-    {
-        id: 1,
-        languageCode: 'en',
-        countryCode: 'US',
-        language: 'English',
-        country: 'United States',
-        isoCode: 'en-US',
-        defaultLanguage: true
-    },
-    {
-        id: 2,
-        languageCode: 'es',
-        countryCode: 'ES',
-        language: 'Spanish',
-        country: 'Spain',
-        isoCode: 'es-ES',
-        defaultLanguage: false
-    }
-];
-
-describe('DotLocalesListResolver', () => {
-    beforeEach(() => {
-        TestBed.configureTestingModule({
-            providers: [
-                {
-                    provide: DotLanguagesService,
-                    useValue: {
-                        get: () => of(mockLanguages)
-                    }
-                }
-            ]
-        });
-    });
-
-    it('should resolve languages list', (done) => {
-        const result = runInInjectionContext(TestBed.inject(EnvironmentInjector), () =>
-            DotLocalesListResolver(null, null)
-        );
-
-        (result as Observable<DotLanguage[]>).subscribe((languages) => {
-            expect(languages).toEqual(mockLanguages);
-            done();
-        });
-    });
-});
diff --git a/core-web/libs/portlets/dot-locales/data-access/src/lib/resolvers/dot-locales-list.resolver.ts b/core-web/libs/portlets/dot-locales/data-access/src/lib/resolvers/dot-locales-list.resolver.ts
deleted file mode 100644
index 6b3fcfc31fda..000000000000
--- a/core-web/libs/portlets/dot-locales/data-access/src/lib/resolvers/dot-locales-list.resolver.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { Observable } from 'rxjs';
-
-import { inject } from '@angular/core';
-import { ActivatedRouteSnapshot, ResolveFn, RouterStateSnapshot } from '@angular/router';
-
-import { DotLanguagesService } from '@dotcms/data-access';
-import { DotLanguage } from '@dotcms/dotcms-models';
-
-export const DotLocalesListResolver: ResolveFn<DotLanguage[]> = (
-    _route: ActivatedRouteSnapshot,
-    _state: RouterStateSnapshot
-): Observable<DotLanguage[]> => {
-    const languageService = inject(DotLanguagesService);
-
-    return languageService.get();
-};
diff --git a/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/dot-locales-list.component.html b/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/dot-locales-list.component.html
index 6917f5129f49..9122792fcf7a 100644
--- a/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/dot-locales-list.component.html
+++ b/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/dot-locales-list.component.html
@@ -6,6 +6,7 @@
                 class="locales-list__search"
                 (input)="dt.filterGlobal($event.target.value, 'contains')"
                 type="text"
+                data-testId="input-search"
                 pInputText />
         </span>
         <button
@@ -53,3 +54,6 @@
         </ng-template>
     </p-table>
 </ng-container>
+
+<p-confirmDialog [key]="dialogKey" [style]="{ width: '30vw' }" />
+<p-toast></p-toast>
diff --git a/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/dot-locales-list.component.spec.ts b/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/dot-locales-list.component.spec.ts
index 0ffb4afcfaa0..130a8b2e77b5 100644
--- a/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/dot-locales-list.component.spec.ts
+++ b/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/dot-locales-list.component.spec.ts
@@ -1,99 +1,84 @@
-import { Spectator, createComponentFactory, byTestId, mockProvider } from '@ngneat/spectator/jest';
-import { provideComponentStore } from '@ngrx/component-store';
+import { Spectator, createComponentFactory, mockProvider, byTestId } from '@ngneat/spectator/jest';
+import { of } from 'rxjs';
 
-import { CommonModule } from '@angular/common';
 import { ActivatedRoute } from '@angular/router';
 
-import { MessageService } from 'primeng/api';
-import { ButtonModule } from 'primeng/button';
-import { InputTextModule } from 'primeng/inputtext';
-import { TableModule } from 'primeng/table';
-import { TagModule } from 'primeng/tag';
+import { ConfirmationService } from 'primeng/api';
+import { Table } from 'primeng/table';
 
-import { DotMessageService } from '@dotcms/data-access';
-import { DotLanguage } from '@dotcms/dotcms-models';
-import { DotActionMenuButtonComponent, DotMessagePipe } from '@dotcms/ui';
-import { MockDotMessageService } from '@dotcms/utils-testing';
+import {
+    DotHttpErrorManagerService,
+    DotLanguagesService,
+    DotMessageService
+} from '@dotcms/data-access';
+import { MockDotMessageService, mockLanguagesISO, mockLocales } from '@dotcms/utils-testing';
 
 import { DotLocalesListComponent } from './dot-locales-list.component';
 import { DotLocalesListStore } from './store/dot-locales-list.store';
 
 const messageServiceMock = new MockDotMessageService({
-    'locale.locale': 'Locale'
+    Default: 'Default'
 });
 
 describe('DotLocalesListComponent', () => {
     let spectator: Spectator<DotLocalesListComponent>;
-
-    const endPointLanguages: DotLanguage[] = [
-        {
-            id: 1,
-            languageCode: 'en',
-            countryCode: 'US',
-            language: 'English',
-            country: 'United States',
-            isoCode: 'en-US',
-            defaultLanguage: true
-        },
-        {
-            id: 2,
-            languageCode: 'es',
-            countryCode: 'ES',
-            language: 'Spanish',
-            country: 'Spain',
-            isoCode: 'es-ES',
-            defaultLanguage: false
-        }
-    ];
-
     const createComponent = createComponentFactory({
         component: DotLocalesListComponent,
-        componentProviders: [provideComponentStore(DotLocalesListStore)],
-        imports: [
-            CommonModule,
-            InputTextModule,
-            ButtonModule,
-            DotMessagePipe,
-            TableModule,
-            DotActionMenuButtonComponent,
-            TagModule
-        ],
+        imports: [],
         providers: [
-            mockProvider(MessageService),
-            {
-                provide: DotMessageService,
-                useValue: messageServiceMock
-            },
             {
                 provide: ActivatedRoute,
                 useValue: {
                     snapshot: {
                         data: {
-                            locales: endPointLanguages
+                            pushPublishEnvironments: [],
+                            isEnterprise: true
                         }
                     }
                 }
-            }
+            },
+            {
+                provide: DotLanguagesService,
+                useValue: {
+                    get: () => of([...mockLocales]),
+                    getISO: () => of(mockLanguagesISO)
+                }
+            },
+
+            DotLocalesListStore,
+            {
+                provide: DotMessageService,
+                useValue: messageServiceMock
+            },
+            mockProvider(DotHttpErrorManagerService),
+            ConfirmationService
         ]
     });
 
     beforeEach(() => (spectator = createComponent()));
 
-    it('should display locales when vm$ emits', () => {
+    it('should display locales when component is initialized', () => {
         spectator.detectChanges();
 
-        expect(spectator.query(byTestId('locale-cell'))).toHaveText('English (en-US)');
+        const localeElements = spectator.queryAll(byTestId('locale-cell'));
+        expect(localeElements.length).toEqual(2);
+        expect(localeElements[0]).toHaveText('English (en-US)');
     });
 
-    it('should display default locale tag', () => {
+    it('should filter locale when using the filer input', () => {
+        const table = spectator.query(Table);
+        jest.spyOn(table, 'filterGlobal');
+
         spectator.detectChanges();
 
-        expect(spectator.query('.p-tag-success')).toHaveText('Default');
+        spectator.typeInElement('Spanish', byTestId('input-search'));
+
+        expect(table.filterGlobal).toHaveBeenCalledWith('Spanish', 'contains');
     });
 
-    it('should display action menu for each locale', () => {
+    it('should display default tag for default locale', () => {
         spectator.detectChanges();
 
-        expect(spectator.query(DotActionMenuButtonComponent)?.actions?.length).toEqual(2);
+        expect(spectator.query('.p-tag-success')).toHaveText('Default');
     });
 });
diff --git a/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/dot-locales-list.component.ts b/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/dot-locales-list.component.ts
index 7a726856defc..1554d05e79c7 100644
--- a/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/dot-locales-list.component.ts
+++ b/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/dot-locales-list.component.ts
@@ -1,17 +1,26 @@
 import { Observable } from 'rxjs';
 
 import { CommonModule } from '@angular/common';
-import { ChangeDetectionStrategy, Component, OnInit } from '@angular/core';
+import { ChangeDetectionStrategy, Component, inject, OnInit } from '@angular/core';
 import { ActivatedRoute } from '@angular/router';
 
+import { MessageService } from 'primeng/api';
 import { ButtonModule } from 'primeng/button';
+import { ConfirmDialogModule } from 'primeng/confirmdialog';
+import { ConfirmPopupModule } from 'primeng/confirmpopup';
+import { DialogService } from 'primeng/dynamicdialog';
 import { InputTextModule } from 'primeng/inputtext';
 import { TableModule } from 'primeng/table';
 import { TagModule } from 'primeng/tag';
+import { ToastModule } from 'primeng/toast';
 
 import { DotActionMenuButtonComponent, DotMessagePipe } from '@dotcms/ui';
 
-import { DotLocaleListViewModel, DotLocalesListStore } from './store/dot-locales-list.store';
+import {
+    DotLocaleListViewModel,
+    DotLocalesListStore,
+    LOCALE_CONFIRM_DIALOG_KEY
+} from './store/dot-locales-list.store';
 
 @Component({
     selector: 'dot-locales-list',
@@ -23,22 +32,25 @@ import { DotLocaleListViewModel, DotLocalesListStore } from './store/dot-locales
         DotMessagePipe,
         TableModule,
         DotActionMenuButtonComponent,
-        TagModule
+        TagModule,
+        ConfirmDialogModule,
+        ConfirmPopupModule,
+        ToastModule
     ],
     templateUrl: './dot-locales-list.component.html',
     styleUrl: './dot-locales-list.component.scss',
-    providers: [DotLocalesListStore],
+    providers: [DotLocalesListStore, DialogService, MessageService],
     changeDetection: ChangeDetectionStrategy.OnPush
 })
 export class DotLocalesListComponent implements OnInit {
-    vm$: Observable<DotLocaleListViewModel> = this.dotLocalesListStore.vm$;
+    private readonly route = inject(ActivatedRoute);
+    store = inject(DotLocalesListStore);
+    dialogKey = LOCALE_CONFIRM_DIALOG_KEY;
 
-    constructor(
-        private readonly route: ActivatedRoute,
-        private readonly dotLocalesListStore: DotLocalesListStore
-    ) {}
+    vm$: Observable<DotLocaleListViewModel> = this.store.vm$;
 
     ngOnInit() {
-        this.dotLocalesListStore.setLocales(this.route.snapshot.data['locales']);
+        const { pushPublishEnvironments, isEnterprise } = this.route.snapshot.data;
+        this.store.loadLocales({ pushPublishEnvironments, isEnterprise });
     }
 }
diff --git a/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/store/dot-locales-list.store.spec.ts b/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/store/dot-locales-list.store.spec.ts
index fbbbfa07fa9a..48e9fa8a8252 100644
--- a/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/store/dot-locales-list.store.spec.ts
+++ b/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/store/dot-locales-list.store.spec.ts
@@ -1,58 +1,147 @@
-import { SpectatorService, createServiceFactory } from '@ngneat/spectator/jest';
+import {
+    SpectatorService,
+    createServiceFactory,
+    mockProvider,
+    SpyObject
+} from '@ngneat/spectator/jest';
+import { of } from 'rxjs';
 
-import { DotLanguage } from '@dotcms/dotcms-models';
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+
+import { ConfirmationService, MessageService } from 'primeng/api';
+import { DialogService } from 'primeng/dynamicdialog';
+
+import {
+    DotHttpErrorManagerService,
+    DotLanguagesService,
+    DotMessageService
+} from '@dotcms/data-access';
+import { DotPushPublishDialogService } from '@dotcms/dotcms-js';
+import { DotEnvironment } from '@dotcms/dotcms-models';
+import { MockDotMessageService, mockLanguagesISO, mockLocales } from '@dotcms/utils-testing';
 
 import { DotLocalesListStore } from './dot-locales-list.store';
 
+const messageServiceMock = new MockDotMessageService({
+    'locales.edit': 'Edit Locale',
+    'locales.set.as.default': 'Set as default',
+    'locales.delete': 'Delete',
+    'locales.push.publish': 'Push Publish',
+    'contenttypes.content.push_publish': 'Push Publish'
+});
+
 describe('DotLocalesListStore', () => {
     let spectator: SpectatorService<DotLocalesListStore>;
+    let languageService: SpyObject<DotLanguagesService>;
+    let messageService: SpyObject<MessageService>;
+    let dotPushPublishDialogService: DotPushPublishDialogService;
 
-    const storeService = createServiceFactory({ service: DotLocalesListStore, providers: [] });
-
-    beforeEach(() => (spectator = storeService()));
-
-    it('should set locales correctly', () => {
-        const languages: DotLanguage[] = [
+    const storeService = createServiceFactory({
+        service: DotLocalesListStore,
+        providers: [
+            mockProvider(DotLanguagesService),
+            mockProvider(DialogService),
+            mockProvider(ConfirmationService),
+            mockProvider(MessageService),
+            mockProvider(DotHttpErrorManagerService),
+            mockProvider(DotPushPublishDialogService),
             {
-                id: 1,
-                languageCode: 'en',
-                countryCode: 'US',
-                language: 'English',
-                country: 'United States',
-                isoCode: 'en-US',
-                defaultLanguage: true
-            },
-            {
-                id: 2,
-                languageCode: 'es',
-                countryCode: 'ES',
-                language: 'Spanish',
-                country: 'Spain',
-                isoCode: 'es-ES',
-                defaultLanguage: false
+                provide: DotMessageService,
+                useValue: messageServiceMock
             }
-        ];
+        ],
+        imports: [HttpClientTestingModule]
+    });
 
-        spectator.service.setLocales(languages);
+    beforeEach(() => {
+        spectator = storeService();
+        languageService = spectator.inject(DotLanguagesService);
+        messageService = spectator.inject(MessageService);
+        dotPushPublishDialogService = spectator.inject(DotPushPublishDialogService);
 
+        languageService.get.mockReturnValue(of([...mockLocales]));
+        languageService.getISO.mockReturnValue(of(mockLanguagesISO));
+        languageService.makeDefault.mockReturnValue(of(null));
+        languageService.delete.mockReturnValue(of(null));
+
+        spectator.service.loadLocales({
+            pushPublishEnvironments: [{ test: 1 }] as unknown as DotEnvironment[],
+            isEnterprise: true
+        });
+    });
+
+    it('should load locales', (done) => {
         spectator.service.vm$.subscribe((viewModel) => {
             expect(viewModel.locales.length).toBe(2);
             expect(viewModel.locales[0].locale).toBe('English (en-US)');
             expect(viewModel.locales[0].language).toBe('English - en');
             expect(viewModel.locales[0].country).toBe('United States - US');
             expect(viewModel.locales[0].defaultLanguage).toBe(true);
+            expect(viewModel.locales[0].variables).toBe('1/5');
+
             expect(viewModel.locales[1].locale).toBe('Spanish (es-ES)');
             expect(viewModel.locales[1].language).toBe('Spanish - es');
             expect(viewModel.locales[1].country).toBe('Spain - ES');
             expect(viewModel.locales[1].defaultLanguage).toBe(false);
+            expect(viewModel.locales[1].variables).toBe('1/1');
+
+            expect(viewModel.countries).toEqual([...mockLanguagesISO.countries]);
+            expect(viewModel.languages).toEqual([...mockLanguagesISO.languages]);
+
+            done();
         });
     });
 
-    it('should handle empty locales array', () => {
-        spectator.service.setLocales([]);
+    it('should make default locale', () => {
+        const mockDefaultLocaleId = 1;
+        spectator.service.makeDefaultLocale(mockDefaultLocaleId);
 
+        expect(languageService.makeDefault).toHaveBeenCalledWith(mockDefaultLocaleId);
+        expect(messageService.add).toHaveBeenCalled();
+    });
+
+    it('should delete locale', () => {
+        const mockLocaleId = 1;
+        spectator.service.deleteLocale(mockLocaleId);
+
+        expect(languageService.delete).toHaveBeenCalledWith(mockLocaleId);
+        expect(messageService.add).toHaveBeenCalled();
+    });
+
+    it('should open the push publish dialog', () => {
+        jest.spyOn(dotPushPublishDialogService, 'open');
+
+        spectator.service.vm$.subscribe((viewModel) => {
+            const pushPublishMenuItem = viewModel.locales[0].actions[1].menuItem;
+
+            pushPublishMenuItem.command();
+
+            expect(dotPushPublishDialogService.open).toHaveBeenCalledWith({
+                assetIdentifier: mockLocales[0].id.toString(),
+                title: 'Push Publish'
+            });
+        });
+    });
+
+    it('should set the local actions correctly', (done) => {
         spectator.service.vm$.subscribe((viewModel) => {
-            expect(viewModel.locales.length).toBe(0);
+            const defaultLocaleActions = viewModel.locales[0].actions.filter((action) =>
+                action?.shouldShow ? action.shouldShow() : true
+            );
+            const notDefaultLocaleActions = viewModel.locales[1].actions.filter((action) =>
+                action?.shouldShow ? action.shouldShow() : true
+            );
+
+            expect(defaultLocaleActions.length).toEqual(2);
+            expect(defaultLocaleActions[0].menuItem.label).toBe('Edit Locale');
+            expect(defaultLocaleActions[1].menuItem.label).toBe('Push Publish');
+
+            expect(notDefaultLocaleActions.length).toEqual(4);
+            expect(notDefaultLocaleActions[0].menuItem.label).toBe('Edit Locale');
+            expect(notDefaultLocaleActions[1].menuItem.label).toBe('Push Publish');
+            expect(notDefaultLocaleActions[2].menuItem.label).toBe('Set as default');
+            expect(notDefaultLocaleActions[3].menuItem.label).toBe('Delete');
+            done();
         });
     });
 });
diff --git a/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/store/dot-locales-list.store.ts b/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/store/dot-locales-list.store.ts
index 67c7cfa8b174..d44a350192ac 100644
--- a/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/store/dot-locales-list.store.ts
+++ b/core-web/libs/portlets/dot-locales/portlet/src/lib/dot-locales-list/store/dot-locales-list.store.ts
@@ -1,13 +1,37 @@
 import { ComponentStore } from '@ngrx/component-store';
+import { forkJoin } from 'rxjs';
 
-import { Injectable } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { inject, Injectable } from '@angular/core';
 
-import { ComponentStatus, DotActionMenuItem, DotLanguage } from '@dotcms/dotcms-models';
+import { MessageService } from 'primeng/api';
+import { DialogService, DynamicDialogRef } from 'primeng/dynamicdialog';
+
+import { catchError, filter, switchMap, take, tap } from 'rxjs/operators';
+
+import {
+    DotHttpErrorManagerService,
+    DotLanguagesService,
+    DotMessageService
+} from '@dotcms/data-access';
+import { DotPushPublishDialogService } from '@dotcms/dotcms-js';
+import {
+    ComponentStatus,
+    DotActionMenuItem,
+    DotEnvironment,
+    DotISOItem,
+    DotLanguage,
+    DotLanguagesISO
+} from '@dotcms/dotcms-models';
+
+import { DotLocaleConfirmationDialogComponent } from '../../share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component';
+import { getLocaleISOCode } from '../../share/utils';
 
 /**
  * Interface for language row data
  */
 export interface DotLocaleRow {
+    id: number;
     locale: string;
     language: string;
     country: string;
@@ -16,64 +40,249 @@ export interface DotLocaleRow {
     actions: DotActionMenuItem[];
 }
 
-export interface DotLocalesListState {
+export interface DotLocalesListState extends DotLanguagesISO {
     status: ComponentStatus;
     locales: DotLocaleRow[];
+    isEnterprise: boolean;
+    pushPublishEnvironments: DotEnvironment[];
 }
 
-export interface DotLocaleListViewModel {
+export interface DotLocaleListViewModel extends DotLanguagesISO {
     locales: DotLocaleRow[];
 }
 
+export const LOCALE_CONFIRM_DIALOG_KEY = 'LOCALE_CONFIRM_DIALOG_KEY';
+
 @Injectable()
 export class DotLocalesListStore extends ComponentStore<DotLocalesListState> {
+    private readonly dialogService = inject(DialogService);
+    private readonly languageService = inject(DotLanguagesService);
+    private readonly dotMessageService = inject(DotMessageService);
+    private readonly messageService = inject(MessageService);
+    private readonly dotHttpErrorManagerService = inject(DotHttpErrorManagerService);
+    private readonly dotPushPublishDialogService = inject(DotPushPublishDialogService);
+
     // Updaters
-    readonly setLocales = this.updater((state: DotLocalesListState, languages: DotLanguage[]) => ({
+    readonly setLocales = this.updater((state: DotLocalesListState, locales: DotLanguage[]) => ({
+        ...state,
+        locales: this.processLanguages(locales, state.isEnterprise, state.pushPublishEnvironments)
+    }));
+
+    readonly setEnterprise = this.updater((state: DotLocalesListState, isEnterprise: boolean) => ({
+        ...state,
+        isEnterprise
+    }));
+
+    readonly setPushPublishEnvironments = this.updater(
+        (state: DotLocalesListState, pushPublishEnvironments: DotEnvironment[]) => ({
+            ...state,
+            pushPublishEnvironments
+        })
+    );
+
+    readonly setCountries = this.updater((state: DotLocalesListState, countries: DotISOItem[]) => ({
+        ...state,
+        countries
+    }));
+
+    readonly setLanguages = this.updater((state: DotLocalesListState, languages: DotISOItem[]) => ({
+        ...state,
+        languages
+    }));
+
+    readonly setStatus = this.updater((state: DotLocalesListState, status: ComponentStatus) => ({
         ...state,
-        locales: this.processLanguages(languages)
+        status
     }));
 
     readonly vm$ = this.select(
         this.state$,
-        ({ locales }): DotLocaleListViewModel => ({
-            locales
+        ({ locales, countries, languages }): DotLocaleListViewModel => ({
+            locales,
+            countries,
+            languages
         })
     );
 
+    //Effects
+    readonly loadLocales = this.effect<{
+        pushPublishEnvironments: DotEnvironment[];
+        isEnterprise: boolean;
+    }>((data$) => {
+        return data$.pipe(
+            tap(() => this.setStatus(ComponentStatus.LOADING)),
+            switchMap(({ isEnterprise, pushPublishEnvironments }) =>
+                forkJoin([this.languageService.get(), this.languageService.getISO()]).pipe(
+                    tap(([languages, ISOData]) => {
+                        this.setCountries(ISOData.countries);
+                        this.setLanguages(ISOData.languages);
+                        this.setEnterprise(isEnterprise);
+                        this.setPushPublishEnvironments(pushPublishEnvironments);
+                        this.setLocales(languages);
+                        this.setStatus(ComponentStatus.IDLE);
+                    })
+                )
+            )
+        );
+    });
+
+    readonly makeDefaultLocale = this.effect<number>((languageId$) => {
+        return languageId$.pipe(
+            tap(() => this.setStatus(ComponentStatus.LOADING)),
+            switchMap((languageId) => this.languageService.makeDefault(languageId)),
+            switchMap(() => this.languageService.get()),
+            tap((languages) => {
+                this.setStatus(ComponentStatus.IDLE);
+                this.setLocales(languages);
+                this.messageService.add({
+                    severity: 'success',
+                    summary: this.dotMessageService.get('locale.notification.success.title'),
+                    detail: this.dotMessageService.get('locale.notification.success.message')
+                });
+            }),
+            catchError((error: HttpErrorResponse) => this.dotHttpErrorManagerService.handle(error))
+        );
+    });
+
+    readonly deleteLocale = this.effect<number>((languageId$) =>
+        languageId$.pipe(
+            tap(() => this.setStatus(ComponentStatus.LOADING)),
+            switchMap((languageId) => this.languageService.delete(languageId)),
+            switchMap(() => this.languageService.get()),
+            tap((languages) => {
+                this.setStatus(ComponentStatus.IDLE);
+                this.setLocales(languages);
+                this.messageService.add({
+                    severity: 'info',
+                    summary: this.dotMessageService.get(
+                        'locale.delete.confirmation.notification.title'
+                    ),
+                    detail: this.dotMessageService.get(
+                        'locale.delete.confirmation.notification.message'
+                    )
+                });
+            }),
+            catchError((error: HttpErrorResponse) => this.dotHttpErrorManagerService.handle(error))
+        )
+    );
+
     constructor() {
-        super({ status: ComponentStatus.IDLE, locales: [] });
+        super({
+            status: ComponentStatus.IDLE,
+            locales: [],
+            countries: [],
+            languages: [],
+            isEnterprise: false,
+            pushPublishEnvironments: []
+        });
     }
 
     /**
      * Private function to process the languages into the format needed for the state
      */
-    private processLanguages(languages: DotLanguage[]): DotLocaleRow[] {
-        return languages.map((language) => ({
-            locale: `${language.language} (${language.isoCode})`,
-            language: `${language.language} - ${language.languageCode}`,
-            country: `${language.country} - ${language.countryCode}`,
-            variables: 'TBD',
-            defaultLanguage: language.defaultLanguage,
+    private processLanguages(
+        locales: DotLanguage[],
+        isEnterprise: boolean,
+        pushPublishEnvironments: DotEnvironment[]
+    ): DotLocaleRow[] {
+        return locales.map((locale) => ({
+            id: locale.id,
+            locale: `${locale.language} (${locale.isoCode})`,
+            language: `${locale.language} - ${locale.languageCode}`,
+            country: `${locale.country} - ${locale.countryCode}`,
+            variables: `${locale.variables?.count}/${locale.variables?.total}`,
+            defaultLanguage: locale.defaultLanguage,
             actions: [
                 {
                     menuItem: {
-                        label: 'Edit',
+                        label: this.dotMessageService.get('locales.edit'),
+                        command: () => {
+                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        }
+                    }
+                },
+                {
+                    menuItem: {
+                        label: this.dotMessageService.get('locales.push.publish'),
                         command: () => {
-                            //TODO: Implement
+                            this.dotPushPublishDialogService.open({
+                                assetIdentifier: locale.id.toString(),
+                                title: this.dotMessageService.get(
+                                    'contenttypes.content.push_publish'
+                                )
+                            });
                         }
                     },
-                    shouldShow: () => true
+                    shouldShow: () => isEnterprise && pushPublishEnvironments.length > 0
                 },
                 {
                     menuItem: {
-                        label: 'Delete',
+                        label: this.dotMessageService.get('locales.set.as.default'),
                         command: () => {
-                            //TODO: Implement
+                            this.callDynamicDialog(
+                                locale,
+                                'locale.set.default.confirmation.title',
+                                'locale.set.default.confirmation.message',
+                                'locale.set.default.confirmation.accept.button',
+                                () => {
+                                    this.makeDefaultLocale(locale.id);
+                                }
+                            );
                         }
                     },
-                    shouldShow: () => true
+                    shouldShow: () => !locale.defaultLanguage
+                },
+                {
+                    menuItem: {
+                        label: this.dotMessageService.get('locales.delete'),
+                        command: () => {
+                            this.callDynamicDialog(
+                                locale,
+                                'locale.delete.confirmation.title',
+                                'locale.delete.confirmation.message',
+                                'delete',
+                                () => {
+                                    this.deleteLocale(locale.id);
+                                }
+                            );
+                        }
+                    },
+                    shouldShow: () => !locale.defaultLanguage
                 }
             ]
         }));
     }
+
+    private callDynamicDialog(
+        locale: DotLanguage,
+        headerLabel: string,
+        messageLabel: string,
+        acceptLabel: string,
+        action: () => void
+    ) {
+        const dialogRef: DynamicDialogRef = this.dialogService.open(
+            DotLocaleConfirmationDialogComponent,
+            {
+                width: '38rem',
+                header: this.dotMessageService.get(
+                    headerLabel,
+                    `${locale.language} (${getLocaleISOCode(locale)})`
+                ),
+                data: {
+                    acceptLabel: this.dotMessageService.get(acceptLabel),
+                    icon: 'pi pi-exclamation-triangle',
+                    ISOCode: getLocaleISOCode(locale),
+                    locale,
+                    message: this.dotMessageService.get(messageLabel)
+                }
+            }
+        );
+
+        dialogRef.onClose
+            .pipe(
+                take(1),
+                filter((isDelete) => isDelete)
+            )
+            .subscribe(action);
+    }
 }
diff --git a/core-web/libs/portlets/dot-locales/portlet/src/lib/lib.routes.ts b/core-web/libs/portlets/dot-locales/portlet/src/lib/lib.routes.ts
index f23858ae6f38..f79ad6db9084 100644
--- a/core-web/libs/portlets/dot-locales/portlet/src/lib/lib.routes.ts
+++ b/core-web/libs/portlets/dot-locales/portlet/src/lib/lib.routes.ts
@@ -1,6 +1,6 @@
 import { Route } from '@angular/router';
 
-import { DotLocalesListResolver } from '@dotcms/portlets/dot-locales/portlet/data-access';
+import { DotEnterpriseLicenseResolver, DotPushPublishEnvironmentsResolver } from '@dotcms/ui';
 
 import { DotLocalesListComponent } from './dot-locales-list/dot-locales-list.component';
 import { DotLocalesShellComponent } from './dot-locales-shell/dot-locales-shell.component';
@@ -13,7 +13,11 @@ export const DotLocalesRoutes: Route[] = [
             {
                 path: '',
                 component: DotLocalesListComponent,
-                resolve: { locales: DotLocalesListResolver }
+                providers: [DotPushPublishEnvironmentsResolver, DotEnterpriseLicenseResolver],
+                resolve: {
+                    pushPublishEnvironments: DotPushPublishEnvironmentsResolver,
+                    isEnterprise: DotEnterpriseLicenseResolver
+                }
             }
         ]
     }
diff --git a/core-web/libs/portlets/dot-locales/portlet/src/lib/share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component.html b/core-web/libs/portlets/dot-locales/portlet/src/lib/share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component.html
new file mode 100644
index 000000000000..a75c49568536
--- /dev/null
+++ b/core-web/libs/portlets/dot-locales/portlet/src/lib/share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component.html
@@ -0,0 +1,24 @@
+<div class="locale-confirmation__message">
+    <i [class]="data.icon"></i>
+    <span [innerHTML]="data.message"></span>
+</div>
+<div class="locale-confirmation__confirmation">
+    <span [innerHTML]="'locale.action.confirmation.text' | dm : [data.ISOCode]"></span>
+    <input #userKey pInputText data-testid="input" />
+</div>
+<div class="locale-confirmation__buttons">
+    <button
+        class="p-button-outlined"
+        [label]="'Cancel' | dm"
+        (click)="ref.close(false)"
+        data-testid="cancel-button"
+        pButton
+        type="button"></button>
+    <button
+        [label]="data.acceptLabel"
+        [disabled]="data.ISOCode !== userKey.value"
+        (click)="ref.close(true)"
+        data-testid="confirm-button"
+        pButton
+        type="button"></button>
+</div>
diff --git a/core-web/libs/portlets/dot-locales/portlet/src/lib/share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component.scss b/core-web/libs/portlets/dot-locales/portlet/src/lib/share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component.scss
new file mode 100644
index 000000000000..122c9acb3f0f
--- /dev/null
+++ b/core-web/libs/portlets/dot-locales/portlet/src/lib/share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component.scss
@@ -0,0 +1,35 @@
+@use "variables" as *;
+
+:host {
+    display: flex;
+    flex-direction: column;
+}
+
+.locale-confirmation__message {
+    display: flex;
+    gap: $spacing-2;
+    word-break: break-word;
+    align-items: flex-start;
+
+    i {
+        color: $color-alert-yellow;
+        font-size: $font-size-lmd;
+    }
+}
+
+.locale-confirmation__confirmation {
+    display: flex;
+    gap: $spacing-1;
+    margin: $spacing-4 0;
+    align-items: center;
+
+    input {
+        flex: 1;
+    }
+}
+
+.locale-confirmation__buttons {
+    display: flex;
+    justify-content: flex-end;
+    gap: $spacing-1;
+}
diff --git a/core-web/libs/portlets/dot-locales/portlet/src/lib/share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component.spec.ts b/core-web/libs/portlets/dot-locales/portlet/src/lib/share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component.spec.ts
new file mode 100644
index 000000000000..4a981643966d
--- /dev/null
+++ b/core-web/libs/portlets/dot-locales/portlet/src/lib/share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component.spec.ts
@@ -0,0 +1,81 @@
+import { Spectator, createComponentFactory } from '@ngneat/spectator';
+import { byTestId } from '@ngneat/spectator/jest';
+
+import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
+
+import { DotMessageService } from '@dotcms/data-access';
+import { DotLanguage } from '@dotcms/dotcms-models';
+import { DotMessagePipe, MockDotMessageService } from '@dotcms/utils-testing';
+
+import { DotLocaleConfirmationDialogComponent } from './DotLocaleConfirmationDialog.component';
+
+const messageServiceMock = new MockDotMessageService({
+    Cancel: 'Cancel'
+});
+
+describe('DotLocaleConfirmationDialogComponent', () => {
+    let spectator: Spectator<DotLocaleConfirmationDialogComponent>;
+    const createComponent = createComponentFactory({
+        component: DotLocaleConfirmationDialogComponent,
+        imports: [DotMessagePipe],
+        providers: [
+            DynamicDialogRef,
+            {
+                provide: DynamicDialogConfig,
+                useValue: {
+                    data: {
+                        acceptLabel: '',
+                        icon: '',
+                        ISOCode: '',
+                        locale: {} as DotLanguage,
+                        message: ''
+                    }
+                }
+            },
+            {
+                provide: DotMessageService,
+                useValue: messageServiceMock
+            }
+        ]
+    });
+    beforeEach(() => (spectator = createComponent()));
+
+    it('should disable the confirm button if input value is different from ISOCode', () => {
+        spectator.component.data.ISOCode = 'en-us';
+        spectator.detectChanges();
+
+        const inputElement = spectator.query<HTMLInputElement>(byTestId('input'));
+
+        spectator.typeInElement('fr-ca', inputElement);
+
+        const acceptButton = spectator.query<HTMLButtonElement>(byTestId('confirm-button'));
+        expect(acceptButton.disabled).toEqual(true);
+    });
+
+    it('should enable the confirm button if input value is same as ISOCode', () => {
+        jest.spyOn(spectator.component.ref, 'close');
+        spectator.component.data.ISOCode = 'en-us';
+        spectator.detectChanges();
+
+        const inputElement = spectator.query<HTMLInputElement>(byTestId('input'));
+        spectator.typeInElement('en-us', inputElement);
+
+        const buttonElement = spectator.query<HTMLButtonElement>(byTestId('confirm-button'));
+
+        spectator.click(buttonElement);
+
+        expect(buttonElement.disabled).toEqual(false);
+        expect(spectator.component.ref.close).toHaveBeenCalledWith(true);
+    });
+
+    it('should close the dialog without confirmation when cancel button is clicked', () => {
+        jest.spyOn(spectator.component.ref, 'close');
+        spectator.detectChanges();
+
+        const cancelButton = spectator.query<HTMLButtonElement>(byTestId('cancel-button'));
+
+        spectator.click(cancelButton);
+
+        expect(spectator.component.ref.close).toHaveBeenCalledWith(false);
+    });
+});
diff --git a/core-web/libs/portlets/dot-locales/portlet/src/lib/share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component.ts b/core-web/libs/portlets/dot-locales/portlet/src/lib/share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component.ts
new file mode 100644
index 000000000000..8340063e35d5
--- /dev/null
+++ b/core-web/libs/portlets/dot-locales/portlet/src/lib/share/ui/DotLocaleConfirmationDialog/DotLocaleConfirmationDialog.component.ts
@@ -0,0 +1,40 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
+
+import { ButtonModule } from 'primeng/button';
+import { DialogModule } from 'primeng/dialog';
+import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
+import { InputTextModule } from 'primeng/inputtext';
+
+import { DotLanguage } from '@dotcms/dotcms-models';
+import { DotMessagePipe } from '@dotcms/ui';
+
+export interface DotLocaleConfirmationDialogData {
+    acceptLabel: string;
+    icon: string;
+    ISOCode: string;
+    locale: DotLanguage;
+    message: string;
+}
+
+@Component({
+    selector: 'dot-locale-confirmation-dialog',
+    standalone: true,
+    imports: [CommonModule, DialogModule, ButtonModule, DotMessagePipe, InputTextModule],
+    templateUrl: './DotLocaleConfirmationDialog.component.html',
+    styleUrl: './DotLocaleConfirmationDialog.component.scss',
+    changeDetection: ChangeDetectionStrategy.OnPush
+})
+export class DotLocaleConfirmationDialogComponent {
+    readonly config: DynamicDialogConfig<DotLocaleConfirmationDialogData> =
+        inject(DynamicDialogConfig);
+    ref = inject(DynamicDialogRef);
+
+    data: DotLocaleConfirmationDialogData = this.config.data || {
+        acceptLabel: '',
+        icon: '',
+        ISOCode: '',
+        locale: {} as DotLanguage,
+        message: ''
+    };
+}
diff --git a/core-web/libs/portlets/dot-locales/portlet/src/lib/share/utils.ts b/core-web/libs/portlets/dot-locales/portlet/src/lib/share/utils.ts
new file mode 100644
index 000000000000..98db531ae242
--- /dev/null
+++ b/core-web/libs/portlets/dot-locales/portlet/src/lib/share/utils.ts
@@ -0,0 +1,9 @@
+import { DotLanguage } from '@dotcms/dotcms-models';
+
+export const getLocaleISOCode = (locale: DotLanguage): string => {
+    if (locale) {
+        return `${locale.languageCode}${locale.countryCode ? `-${locale.countryCode}` : ''}`;
+    }
+
+    return '';
+};
diff --git a/core-web/libs/utils-testing/src/lib/dot-language.mock.ts b/core-web/libs/utils-testing/src/lib/dot-language.mock.ts
index b073d7bdc954..bfff0abea473 100644
--- a/core-web/libs/utils-testing/src/lib/dot-language.mock.ts
+++ b/core-web/libs/utils-testing/src/lib/dot-language.mock.ts
@@ -1,4 +1,4 @@
-import { DotLanguage } from '@dotcms/dotcms-models';
+import { DotLanguage, DotLanguagesISO } from '@dotcms/dotcms-models';
 
 export const mockDotLanguage: DotLanguage = {
     id: 1,
@@ -20,3 +20,37 @@ export const mockLanguageArray: DotLanguage[] = [
     mockDotLanguage,
     mockDotLanguageWithoutCountryCode
 ];
+
+export const mockLocales: DotLanguage[] = [
+    {
+        id: 1,
+        languageCode: 'en',
+        countryCode: 'US',
+        language: 'English',
+        country: 'United States',
+        isoCode: 'en-US',
+        defaultLanguage: true,
+        variables: { count: 1, total: 5 }
+    },
+    {
+        id: 2,
+        languageCode: 'es',
+        countryCode: 'ES',
+        language: 'Spanish',
+        country: 'Spain',
+        isoCode: 'es-ES',
+        defaultLanguage: false,
+        variables: { count: 1, total: 1 }
+    }
+];
+
+export const mockLanguagesISO: DotLanguagesISO = {
+    countries: [
+        { code: 'US', name: 'United States' },
+        { code: 'CA', name: 'Canada' }
+    ],
+    languages: [
+        { code: 'en', name: 'English' },
+        { code: 'es', name: 'Spanish' }
+    ]
+};
diff --git a/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties b/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
index c74d323920bf..6710c2d7d330 100644
--- a/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
+++ b/dotCMS/src/main/webapp/WEB-INF/messages/Language.properties
@@ -5676,11 +5676,31 @@ block-editor.extension.ai.confirmation.header=Discard Changes?
 block-editor.extension.ai.confirmation.message=It looks like you've made significant or complex edits. Are you sure you want to discard these changes? Any unsaved progress will be lost.
 
 locales.add.locale=Add Locale
+locales.edit.locale=Edit Locale
 locales.locale=Locale
 locales.language=Language
 locales.country=Country
 locales.variables=Variables
+locales.edit.locale=Edit Locale
+locales.add.locale=Add Locale
 locales.menu=Menu
+locales.edit=Edit Locale
+locales.push.publish=Push Publish
+locales.delete=Delete
+locales.set.as.default=Set As Default
+locales.language.input.placeholder=Select form list or type
+locales.language.hint=Select the language you want to add from the ISO language list.
+locales.country.hint=If you wish to add a specific location for the language select from the list.
+locale.set.default.confirmation.title=Are you sure you want to set ${0} as the default?
+locale.set.default.confirmation.message=Setting this language as the default will alter the language of all site content and communications.<br><br>Be mindful of any unintended consequences.
+locale.set.default.confirmation.accept.button=Set as Default
+locale.delete.confirmation.title=Are you sure you want to delete {0} locale?
+locale.delete.confirmation.message=<b>Attention:</b> This action will permanently remove the selected locale and all associated content items from your site.<br><br>Please review your decision carefully before proceeding.
+locale.delete.confirmation.notification.title=Locale Deletion In Progress
+locale.delete.confirmation.notification.message=Removal process running, it may take some time.
+locale.action.confirmation.text=Type <b>{0}</b> to confirm
+locale.notification.success.title=Changes Saved
+locale.notification.success.message=Your changes have been saved.
 
 editpage.language-change-missing-lang-populate.confirm.header=Create New Language Version?
 editpage.language-change-missing-lang-populate.confirm.message=Page does not exist in the selected language. Create a new version in {0}?