diff --git a/Marco.Pms.Services/Controllers/MasterController.cs b/Marco.Pms.Services/Controllers/MasterController.cs
index ebd8998..85b5f14 100644
--- a/Marco.Pms.Services/Controllers/MasterController.cs
+++ b/Marco.Pms.Services/Controllers/MasterController.cs
@@ -1,12 +1,10 @@
 using Marco.Pms.DataAccess.Data;
 using Marco.Pms.Model.Dtos.Activities;
 using Marco.Pms.Model.Dtos.Master;
-using Marco.Pms.Model.Entitlements;
 using Marco.Pms.Model.Forum;
 using Marco.Pms.Model.Mapper;
 using Marco.Pms.Model.Master;
 using Marco.Pms.Model.Utilities;
-using Marco.Pms.Model.ViewModels.Activities;
 using Marco.Pms.Model.ViewModels.Forum;
 using Marco.Pms.Model.ViewModels.Master;
 using Marco.Pms.Services.Helpers;
@@ -35,155 +33,96 @@ namespace Marco.Pms.Services.Controllers
             _masterHelper = masterHelper;
         }
 
+        // --------------------------------  Services  --------------------------------
+
+        [HttpGet("services")]
+        public async Task<IActionResult> GetServices()
+        {
+            var response = await _masterHelper.GetServices();
+            return StatusCode(response.StatusCode, response);
+        }
+
+        [HttpPost("service")]
+        public async Task<IActionResult> CreateService([FromBody] ServiceMasterDto serviceMasterDto)
+        {
+            var response = await _masterHelper.CreateService(serviceMasterDto);
+            return StatusCode(response.StatusCode, response);
+        }
+
+        [HttpPut("service/{id}")]
+        public async Task<IActionResult> UpdateService(Guid id, [FromBody] ServiceMasterDto serviceMasterDto)
+        {
+            var response = await _masterHelper.UpdateService(id, serviceMasterDto);
+            return StatusCode(response.StatusCode, response);
+        }
+
+        [HttpDelete("service/{id}")]
+        public async Task<IActionResult> DeleteService(Guid id, [FromQuery] bool? isActive)
+        {
+            var response = await _masterHelper.DeleteService(id, isActive ?? false);
+            return StatusCode(response.StatusCode, response);
+        }
+
+
+        // --------------------------------  Activity Group  --------------------------------
+
+        [HttpGet("activity-groups")]
+        public async Task<IActionResult> GetActivityGroups()
+        {
+            var response = await _masterHelper.GetActivityGroups();
+            return StatusCode(response.StatusCode, response);
+        }
+
+        [HttpPost("activity-group")]
+        public async Task<IActionResult> CreateActivityGroup([FromBody] ActivityGroupDto activityGroupDto)
+        {
+            var response = await _masterHelper.CreateActivityGroup(activityGroupDto);
+            return StatusCode(response.StatusCode, response);
+        }
+
+        [HttpPut("activity-group/{id}")]
+        public async Task<IActionResult> UpdateActivityGroup(Guid id, [FromBody] ActivityGroupDto activityGroupDto)
+        {
+            var response = await _masterHelper.UpdateActivityGroup(id, activityGroupDto);
+            return StatusCode(response.StatusCode, response);
+
+        }
+
+        [HttpDelete("activity-group/{id}")]
+        public async Task<IActionResult> DeleteActivityGroup(Guid id, [FromQuery] bool? isActive)
+        {
+            var response = await _masterHelper.DeleteActivityGroup(id, isActive ?? false);
+            return StatusCode(response.StatusCode, response);
+        }
+
         // --------------------------------  Activity  --------------------------------
-        [HttpGet]
-        [Route("activities")]
+        [HttpGet("activities")]
         public async Task<IActionResult> GetActivitiesMaster()
         {
-            Guid tenantId = _userHelper.GetTenantId();
-            var activities = await _context.ActivityMasters.Where(c => c.TenantId == tenantId && c.IsActive == true).ToListAsync();
-            List<ActivityVM> activitiesVM = new List<ActivityVM>();
-            foreach (var activity in activities)
-            {
-                var checkList = await _context.ActivityCheckLists.Where(c => c.TenantId == tenantId && c.ActivityId == activity.Id).ToListAsync();
-                List<CheckListVM> checkListVM = new List<CheckListVM>();
-                if (checkList != null)
-                {
-                    foreach (ActivityCheckList check in checkList)
-                    {
-                        var checkVM = check.ToCheckListVMFromActivityCheckList(activity.Id, false);
-                        checkListVM.Add(checkVM);
-                    }
-                }
-
-                ActivityVM activityVM = activity.ToActivityVMFromActivityMaster(checkListVM);
-                activitiesVM.Add(activityVM);
-            }
-            _logger.LogInfo("{count} activity records fetched successfully from tenant {tenantId}", activitiesVM.Count, tenantId);
-            return Ok(ApiResponse<object>.SuccessResponse(activitiesVM, System.String.Format("{0} activity records fetched successfully", activitiesVM.Count), 200));
+            var response = await _masterHelper.GetActivitiesMaster();
+            return StatusCode(response.StatusCode, response);
         }
 
         [HttpPost("activity")]
         public async Task<IActionResult> CreateActivity([FromBody] CreateActivityMasterDto createActivity)
         {
-            Guid tenantId = _userHelper.GetTenantId();
-            var employee = await _userHelper.GetCurrentEmployeeAsync();
-            if (employee.TenantId != tenantId)
-            {
-                _logger.LogWarning("User from tenant {employeeTenantId} tries to access data from tenant {tenantId}", employee.TenantId, tenantId);
-                return Unauthorized(ApiResponse<object>.ErrorResponse("Current tenant did not match with user's tenant", "Current tenant did not match with user's tenant", 401));
-            }
-            var activityMaster = createActivity.ToActivityMasterFromCreateActivityMasterDto(tenantId);
-            _context.ActivityMasters.Add(activityMaster);
-            await _context.SaveChangesAsync();
-            List<CheckListVM> checkListVM = new List<CheckListVM>();
-
-            if (createActivity.CheckList != null)
-            {
-                List<ActivityCheckList> activityCheckList = new List<ActivityCheckList>();
-                foreach (var check in createActivity.CheckList)
-                {
-                    ActivityCheckList checkList = check.ToActivityCheckListFromCreateCheckListDto(tenantId, activityMaster.Id);
-                    activityCheckList.Add(checkList);
-                }
-                _context.ActivityCheckLists.AddRange(activityCheckList);
-                await _context.SaveChangesAsync();
-
-                foreach (ActivityCheckList check in activityCheckList)
-                {
-                    var checkVM = check.ToCheckListVMFromActivityCheckList(activityMaster.Id, false);
-                    checkListVM.Add(checkVM);
-                }
-            }
-            ActivityVM activityVM = activityMaster.ToActivityVMFromActivityMaster(checkListVM);
-
-            _logger.LogInfo("activity created successfully from tenant {tenantId}", tenantId);
-            return Ok(ApiResponse<object>.SuccessResponse(activityVM, "activity created successfully", 200));
+            var response = await _masterHelper.CreateActivity(createActivity);
+            return StatusCode(response.StatusCode, response);
         }
 
-        [HttpPost("activity/edit/{id}")]
+        [HttpPut("activity/{id}")]
         public async Task<IActionResult> UpdateActivity(Guid id, [FromBody] CreateActivityMasterDto createActivity)
         {
-            Guid tenantId = _userHelper.GetTenantId();
-            var employee = await _userHelper.GetCurrentEmployeeAsync();
-            ActivityMaster? activity = await _context.ActivityMasters.FirstOrDefaultAsync(x => x.Id == id && x.IsActive == true && x.TenantId == tenantId);
-            if (activity != null && createActivity.UnitOfMeasurement != null && createActivity.ActivityName != null)
-            {
+            var response = await _masterHelper.UpdateActivity(id, createActivity);
+            return StatusCode(response.StatusCode, response);
 
-                activity.ActivityName = createActivity.ActivityName;
-                activity.UnitOfMeasurement = createActivity.UnitOfMeasurement;
-                List<ActivityCheckList> activityCheckLists = await _context.ActivityCheckLists.AsNoTracking().Where(c => c.ActivityId == activity.Id).ToListAsync();
-                List<CheckListVM> checkListVM = new List<CheckListVM>();
-
-                if (createActivity.CheckList != null)
-                {
-
-                    var newCheckIds = createActivity.CheckList.Select(c => c.Id);
-
-                    List<ActivityCheckList> updateCheckList = new List<ActivityCheckList>();
-                    List<ActivityCheckList> deleteCheckList = new List<ActivityCheckList>();
-                    if (newCheckIds.Contains(null))
-                    {
-                        foreach (var check in createActivity.CheckList)
-                        {
-                            if (check.Id == null)
-                            {
-                                ActivityCheckList checkList = check.ToActivityCheckListFromCreateCheckListDto(tenantId, activity.Id);
-                                updateCheckList.Add(checkList);
-                            }
-                        }
-                    }
-                    foreach (var check in activityCheckLists)
-                    {
-                        if (newCheckIds.Contains(check.Id))
-                        {
-                            var updatedCheck = createActivity.CheckList.Find(c => c.Id == check.Id);
-                            ActivityCheckList checkList = updatedCheck != null ? updatedCheck.ToActivityCheckListFromCreateCheckListDto(tenantId, activity.Id) : new ActivityCheckList();
-                            updateCheckList.Add(checkList);
-                        }
-                        else
-                        {
-                            deleteCheckList.Add(check);
-                        }
-                    }
-                    _context.ActivityCheckLists.UpdateRange(updateCheckList);
-                    if (deleteCheckList != null)
-                    {
-                        _context.ActivityCheckLists.RemoveRange(deleteCheckList);
-                    }
-                    await _context.SaveChangesAsync();
-
-                    foreach (ActivityCheckList check in updateCheckList)
-                    {
-                        var checkVM = check.ToCheckListVMFromActivityCheckList(activity.Id, false);
-                        checkListVM.Add(checkVM);
-                    }
-                }
-                else if (activityCheckLists != null)
-                {
-                    _context.ActivityCheckLists.RemoveRange(activityCheckLists);
-                    await _context.SaveChangesAsync();
-                }
-                ActivityVM activityVM = activity.ToActivityVMFromActivityMaster(checkListVM);
-                _logger.LogInfo("activity updated successfully from tenant {tenantId}", tenantId);
-                return Ok(ApiResponse<object>.SuccessResponse(activityVM, "activity updated successfully", 200));
-            }
-            _logger.LogError("Activity {ActivityId} not found", id);
-            return NotFound(ApiResponse<object>.ErrorResponse("Activity not found", "Activity not found", 404));
         }
 
-        [HttpDelete("activity/delete/{id}")]
-        public async Task<IActionResult> DeleteActivity(Guid Id)
+        [HttpDelete("activity/{id}")]
+        public async Task<IActionResult> DeleteActivity(Guid id, [FromQuery] bool? isActive)
         {
-            Guid tenantId = _userHelper.GetTenantId();
-            var activity = await _context.ActivityMasters.FirstOrDefaultAsync(a => a.Id == Id && a.TenantId == tenantId);
-            if (activity != null)
-            {
-                activity.IsActive = false;
-            }
-            await _context.SaveChangesAsync();
-            _logger.LogInfo("Activity Deleted Successfully from tenant {tenantId}", tenantId);
-            return Ok(ApiResponse<object>.SuccessResponse(new { }, "Activity Deleted Successfully", 200));
+            var response = await _masterHelper.DeleteActivity(id, isActive ?? false);
+            return StatusCode(response.StatusCode, response);
         }
 
         // --------------------------------  Industry  --------------------------------