diff --git a/src/nodejs/hooks/sealights.go b/src/nodejs/hooks/sealights.go
index 3b8893c9a..b020e545e 100644
--- a/src/nodejs/hooks/sealights.go
+++ b/src/nodejs/hooks/sealights.go
@@ -60,6 +60,7 @@ type SealightsParameters struct {
 	ProxyPassword      string
 	ProjectRoot        string
 	TestStage          string
+	NpmRunScript       string
 }
 
 type SealightsRunOptions struct {
@@ -155,8 +156,17 @@ func (sl *SealightsHook) SetApplicationStartInProcfile(stager *libbuildpack.Stag
 	originalStartCommand := string(bytes)
 	_, usePackageJson := sl.usePackageJson(originalStartCommand, stager)
 	if usePackageJson {
+		// Extract script name from command or use configured default
+		scriptName, err := sl.ExtractNpmRunScriptName(originalStartCommand)
+		if err != nil {
+			sl.Log.Warning("Failed to extract script name from command '%s', using configured default: %s", originalStartCommand, err)
+			scriptName = sl.parameters.NpmRunScript
+			if scriptName == "" {
+				scriptName = "start"
+			}
+		}
 		// move to package json scenario
-		return sl.SetApplicationStartInPackageJson(stager)
+		return sl.SetApplicationStartInPackageJson(stager, scriptName)
 	}
 
 	// we suppose that format is "web: node <application>"
@@ -182,6 +192,62 @@ func (sl *SealightsHook) SetApplicationStartInProcfile(stager *libbuildpack.Stag
 	return nil
 }
 
+func (sl *SealightsHook) ExtractNpmRunScriptName(command string) (string, error) {
+	// Remove leading "web:" prefix if present
+	cleanCommand := strings.TrimSpace(command)
+	if strings.HasPrefix(cleanCommand, "web:") {
+		cleanCommand = strings.TrimSpace(cleanCommand[4:])
+	}
+	
+	// Handle commands with cd prefix (e.g., "cd app && npm run start")
+	if strings.Contains(cleanCommand, "&&") {
+		parts := strings.Split(cleanCommand, "&&")
+		if len(parts) >= 2 {
+			cleanCommand = strings.TrimSpace(parts[len(parts)-1])
+		}
+	}
+	
+	// Extract script name from npm commands
+	// Patterns to match:
+	// - "npm start" -> "start"
+	// - "npm run start-dev" -> "start-dev"
+	// - "npm run dev" -> "dev"
+	patterns := []string{
+		`^npm\s+run\s+([a-zA-Z0-9\-_]+)`,     // npm run <script>
+		`^npm\s+([a-zA-Z0-9\-_]+)`,           // npm <script>
+	}
+	
+	for _, pattern := range patterns {
+		re, err := regexp.Compile(pattern)
+		if err != nil {
+			sl.Log.Warning("Failed to compile regex pattern %s: %s", pattern, err)
+			continue
+		}
+		
+		matches := re.FindStringSubmatch(cleanCommand)
+		if len(matches) >= 2 {
+			scriptName := matches[1]
+			sl.Log.Debug("Extracted npm script name: %s from command: %s", scriptName, command)
+			return scriptName, nil
+		}
+	}
+	
+	return "", fmt.Errorf("failed to extract npm script name from command: %s", command)
+}
+
+func (sl *SealightsHook) ValidateNpmRunScript(packageJson map[string]interface{}, scriptName string) error {
+	scripts, ok := packageJson["scripts"].(map[string]interface{})
+	if !ok || scripts == nil {
+		return fmt.Errorf("no scripts section found in package.json")
+	}
+	
+	if _, exists := scripts[scriptName]; !exists {
+		return fmt.Errorf("script '%s' not found in package.json", scriptName)
+	}
+	
+	return nil
+}
+
 func (sl *SealightsHook) usePackageJson(originalStartCommand string, stager *libbuildpack.Stager) (error, bool) {
 
 	isNpmCommand, err := regexp.MatchString(`(^(web:\s)?cd[^&]*\s&&\snpm)|(^(web:\s)?npm)`, originalStartCommand)
@@ -251,26 +317,43 @@ func (sl *SealightsHook) getSealightsOptions(app string) *SealightsRunOptions {
 	return o
 }
 
-func (sl *SealightsHook) SetApplicationStartInPackageJson(stager *libbuildpack.Stager) error {
+func (sl *SealightsHook) SetApplicationStartInPackageJson(stager *libbuildpack.Stager, targetScript string) error {
 	packageJson, err := sl.ReadPackageJson(stager)
 	if err != nil {
 		return err
 	}
-	scripts, _ := packageJson["scripts"].(map[string]interface{})
-	if scripts == nil {
-		return fmt.Errorf("failed to read scripts from %s", PackageJsonFile)
+	
+	// Validate that the target script exists
+	err = sl.ValidateNpmRunScript(packageJson, targetScript)
+	if err != nil {
+		// Try fallback to "start" if configured script doesn't exist
+		if targetScript != "start" {
+			sl.Log.Warning("Script '%s' not found, falling back to 'start': %s", targetScript, err)
+			fallbackErr := sl.ValidateNpmRunScript(packageJson, "start")
+			if fallbackErr != nil {
+				return fmt.Errorf("target script '%s' not found and fallback to 'start' failed: %s", targetScript, fallbackErr)
+			}
+			targetScript = "start"
+		} else {
+			return err
+		}
 	}
-	originalStartScript, _ := scripts["start"].(string)
+	
+	scripts := packageJson["scripts"].(map[string]interface{})
+	originalStartScript, _ := scripts[targetScript].(string)
 	if originalStartScript == "" {
-		return fmt.Errorf("failed to read start from scripts in %s", PackageJsonFile)
+		return fmt.Errorf("failed to read %s script from %s", targetScript, PackageJsonFile)
 	}
-	// we suppose that format is "start: node <application>"
+	
+	// Update the command with Sealights injection
 	var newCmd string
 	newCmd, err = sl.updateStartCommand(originalStartScript)
 	if err != nil {
 		return err
 	}
-	packageJson["scripts"].(map[string]interface{})["start"] = newCmd
+	
+	sl.Log.Debug("Injecting Sealights into '%s' script: %s -> %s", targetScript, originalStartScript, newCmd)
+	scripts[targetScript] = newCmd
 
 	err = libbuildpack.NewJSON().Write(filepath.Join(stager.BuildDir(), PackageJsonFile), packageJson)
 	if err != nil {
@@ -284,9 +367,9 @@ func (sl *SealightsHook) SetApplicationStartInPackageJson(stager *libbuildpack.S
 func (sl *SealightsHook) ReadPackageJson(stager *libbuildpack.Stager) (map[string]interface{}, error) {
 	p := map[string]interface{}{}
 
-	if err := libbuildpack.NewJSON().Load(filepath.Join(stager.BuildDir(), "package.json"), &p); err != nil {
+	if err := libbuildpack.NewJSON().Load(filepath.Join(stager.BuildDir(), PackageJsonFile), &p); err != nil {
 		if err != nil {
-			sl.Log.Error("failed to read %s error: %s", Procfile, err.Error())
+			sl.Log.Error("failed to read %s error: %s", PackageJsonFile, err.Error())
 			return nil, err
 		}
 	}
@@ -303,11 +386,20 @@ func (sl *SealightsHook) SetApplicationStartInManifest(stager *libbuildpack.Stag
 
 	_, usePackageJson := sl.usePackageJson(originalStartCommand, stager)
 	if usePackageJson {
+		// Extract script name from command or use configured default
+		scriptName, err := sl.ExtractNpmRunScriptName(originalStartCommand)
+		if err != nil {
+			sl.Log.Warning("Failed to extract script name from command '%s', using configured default: %s", originalStartCommand, err)
+			scriptName = sl.parameters.NpmRunScript
+			if scriptName == "" {
+				scriptName = "start"
+			}
+		}
 		// move to package json scenario
-		return sl.SetApplicationStartInPackageJson(stager)
+		return sl.SetApplicationStartInPackageJson(stager, scriptName)
 	}
 
-	// we suppose that format is "start: node <application>"
+	// we suppose that format is "node <application>"
 	var newCmd string
 	newCmd, err = sl.updateStartCommand(originalStartCommand)
 	if err != nil {
@@ -437,8 +529,13 @@ func (sl *SealightsHook) injectSealights(stager *libbuildpack.Stager) error {
 		sl.Log.Info("Integrating sealights into manifest.yml")
 		return sl.SetApplicationStartInManifest(stager)
 	} else {
-		sl.Log.Info("Integrating sealights into package.json")
-		return sl.SetApplicationStartInPackageJson(stager)
+	sl.Log.Info("Integrating sealights into package.json")
+	// Use configured script name or default to "start"
+	scriptName := sl.parameters.NpmRunScript
+	if scriptName == "" {
+		scriptName = "start"
+	}
+	return sl.SetApplicationStartInPackageJson(stager, scriptName)
 	}
 }
 
@@ -487,6 +584,7 @@ func (sl *SealightsHook) parseVcapServices() {
 				ProxyPassword:      queryString("proxyPassword"),
 				ProjectRoot:        queryString("projectRoot"),
 				TestStage:          queryString("testStage"),
+				NpmRunScript:       queryString("npmRunScript"),
 			}
 
 			// write warning in case token is not provided
diff --git a/src/nodejs/hooks/sealights_test.go b/src/nodejs/hooks/sealights_test.go
index 60fb7adba..b02f8623d 100644
--- a/src/nodejs/hooks/sealights_test.go
+++ b/src/nodejs/hooks/sealights_test.go
@@ -289,6 +289,39 @@ var _ = Describe("Sealights hook", func() {
 				expectedCommand := strings.ReplaceAll("./node_modules/.bin/slnodejs run --useinitialcolor true --token good_token --buildsessionid goodBsid --proxy goodProxy --proxyUsername goodName --proxyPassword goodPassword --labid goodLab --projectroot ./ --teststage \"Good tests\" index.js --build 192 --name Good", " ", "")
 				Expect(cleanResult).To(Equal("web:" + expectedCommand))
 			})
+
+			It("should use custom npmRunScript parameter for npm commands", func() {
+				err = os.WriteFile(filepath.Join(stager.BuildDir(), procfileName), []byte("web: npm run dev"), 0755)
+				Expect(err).To(BeNil())
+				
+				customPackageJson := "{\n    \"scripts\": {\n        \"dev\": \"" + originalStartCommand + "\",\n        \"start\": \"node index.js\"\n    }\n}"
+				err = os.WriteFile(filepath.Join(stager.BuildDir(), packageJsonName), []byte(customPackageJson), 0755)
+				Expect(err).To(BeNil())
+
+				vcapTemplate := `{
+					"user-provided":[{
+						"label": "user-provided",
+						"name": "sealights",
+						"credentials": {
+							"token": "` + token + `",
+							"buildSessionId": "` + bsid + `",
+							"npmRunScript": "dev"
+						}
+					}]
+				}`
+				err = os.Setenv("VCAP_SERVICES", vcapTemplate)
+				Expect(err).To(BeNil())
+
+				err = sealights.AfterCompile(stager)
+				Expect(err).To(BeNil())
+				
+				packageJson, err := sealights.ReadPackageJson(stager)
+				Expect(err).To(BeNil())
+				
+				devScript := packageJson["scripts"].(map[string]interface{})["dev"].(string)
+				Expect(devScript).To(ContainSubstring("slnodejs"))
+				Expect(devScript).To(ContainSubstring("index.js --build 192 --name Good"))
+			})
 		})
 
 		Context("Sealights injection", func() {
@@ -363,7 +396,7 @@ var _ = Describe("Sealights hook", func() {
 				})
 
 				It("fail to find scripts section in package.json", func() {
-					err = sealights.SetApplicationStartInPackageJson(stager)
+					err = sealights.SetApplicationStartInPackageJson(stager, "start")
 					Expect(err).ShouldNot(BeNil())
 				})
 			})
@@ -379,7 +412,7 @@ var _ = Describe("Sealights hook", func() {
 				})
 
 				It("fail to start under scripts section in package.json", func() {
-					err = sealights.SetApplicationStartInPackageJson(stager)
+					err = sealights.SetApplicationStartInPackageJson(stager, "start")
 					Expect(err).ShouldNot(BeNil())
 				})
 			})
@@ -397,7 +430,7 @@ var _ = Describe("Sealights hook", func() {
 					Expect(err).To(BeNil())
 					err = os.Setenv("SL_TEST_STAGE", stage)
 					Expect(err).To(BeNil())
-					err = sealights.SetApplicationStartInPackageJson(stager)
+					err = sealights.SetApplicationStartInPackageJson(stager, "start")
 					Expect(err).To(BeNil())
 					packageJson, err := sealights.ReadPackageJson(stager)
 					Expect(err).To(BeNil())
@@ -409,7 +442,7 @@ var _ = Describe("Sealights hook", func() {
 					Expect(err).NotTo(HaveOccurred())
 					err = os.Setenv("SL_BUILD_SESSION_ID_FILE", "")
 					Expect(err).NotTo(HaveOccurred())
-					err = sealights.SetApplicationStartInPackageJson(stager)
+					err = sealights.SetApplicationStartInPackageJson(stager, "start")
 					Expect(err).To(MatchError(ContainSubstring(hooks.EmptyBuildError)))
 				})
 				It("test application run cmd creation", func() {
@@ -422,7 +455,7 @@ var _ = Describe("Sealights hook", func() {
 					err = os.Setenv("SL_BUILD_SESSION_ID_FILE", "")
 					Expect(err).NotTo(HaveOccurred())
 					Expect(err).To(BeNil())
-					err = sealights.SetApplicationStartInPackageJson(stager)
+					err = sealights.SetApplicationStartInPackageJson(stager, "start")
 					packageJson, err := sealights.ReadPackageJson(stager)
 					Expect(err).To(BeNil())
 					cleanResult := strings.ReplaceAll(packageJson["scripts"].(map[string]interface{})["start"].(string), " ", "")
@@ -571,5 +604,152 @@ var _ = Describe("Sealights hook", func() {
 				Expect(command.args[1]).To(Equal("slnodejs@" + customVersion))
 			})
 		})
+
+		Context("extractNpmRunScriptName function", func() {
+			It("should extract script name from npm run command", func() {
+				scriptName, err := sealights.ExtractNpmRunScriptName("web: npm run start-dev")
+				Expect(err).To(BeNil())
+				Expect(scriptName).To(Equal("start-dev"))
+			})
+
+			It("should extract script name from npm command without run", func() {
+				scriptName, err := sealights.ExtractNpmRunScriptName("web: npm start")
+				Expect(err).To(BeNil())
+				Expect(scriptName).To(Equal("start"))
+			})
+
+			It("should extract script name from command with cd prefix", func() {
+				scriptName, err := sealights.ExtractNpmRunScriptName("web: cd app && npm run dev")
+				Expect(err).To(BeNil())
+				Expect(scriptName).To(Equal("dev"))
+			})
+
+			It("should extract script name from simple npm run command", func() {
+				scriptName, err := sealights.ExtractNpmRunScriptName("npm run test")
+				Expect(err).To(BeNil())
+				Expect(scriptName).To(Equal("test"))
+			})
+
+			It("should handle commands with hyphens and underscores", func() {
+				scriptName, err := sealights.ExtractNpmRunScriptName("npm run start-prod_env")
+				Expect(err).To(BeNil())
+				Expect(scriptName).To(Equal("start-prod_env"))
+			})
+
+			It("should fail for non-npm commands", func() {
+				_, err := sealights.ExtractNpmRunScriptName("web: node server.js")
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("failed to extract npm script name"))
+			})
+		})
+
+		Context("validateNpmRunScript function", func() {
+			var packageJson map[string]interface{}
+
+			BeforeEach(func() {
+				packageJson = map[string]interface{}{
+					"scripts": map[string]interface{}{
+						"start":    "node server.js",
+						"test":     "mocha",
+						"dev":      "nodemon server.js",
+						"build":    "webpack",
+					},
+				}
+			})
+
+			It("should validate existing script", func() {
+				err := sealights.ValidateNpmRunScript(packageJson, "start")
+				Expect(err).To(BeNil())
+			})
+
+			It("should validate existing custom script", func() {
+				err := sealights.ValidateNpmRunScript(packageJson, "dev")
+				Expect(err).To(BeNil())
+			})
+
+			It("should fail for non-existing script", func() {
+				err := sealights.ValidateNpmRunScript(packageJson, "nonexistent")
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("script 'nonexistent' not found"))
+			})
+
+			It("should fail for package.json without scripts section", func() {
+				packageJsonWithoutScripts := map[string]interface{}{
+					"name": "test-app",
+				}
+				err := sealights.ValidateNpmRunScript(packageJsonWithoutScripts, "start")
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("no scripts section found"))
+			})
+
+			It("should fail for package.json with null scripts section", func() {
+				packageJsonWithNullScripts := map[string]interface{}{
+					"scripts": nil,
+				}
+				err := sealights.ValidateNpmRunScript(packageJsonWithNullScripts, "start")
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("no scripts section found"))
+			})
+		})
+
+		Context("custom npm script support", func() {
+			BeforeEach(func() {
+				err = os.WriteFile(filepath.Join(stager.BuildDir(), procfileName), []byte("web: npm run custom-script"), 0755)
+				Expect(err).To(BeNil())
+				
+				customPackageJson := "{\n    \"scripts\": {\n        \"custom-script\": \"" + originalStartCommand + "\",\n        \"start\": \"node index.js\"\n    }\n}"
+				err = os.WriteFile(filepath.Join(stager.BuildDir(), packageJsonName), []byte(customPackageJson), 0755)
+				Expect(err).To(BeNil())
+
+				os.Setenv("VCAP_SERVICES", `{"user-provided":[
+					{ 
+						"label": "user-provided",
+						"name": "sealights",
+						"credentials": {
+							"token": "`+token+`"
+						}
+					}
+				]}`)
+			})
+
+			AfterEach(func() {
+				os.Remove(filepath.Join(stager.BuildDir(), packageJsonName))
+			})
+
+			It("should inject sealights into custom npm script", func() {
+				err = os.Setenv("SL_LAB_ID", lab)
+				Expect(err).To(BeNil())
+				err = os.Setenv("SL_PROJECT_ROOT", root)
+				Expect(err).To(BeNil())
+				err = os.Setenv("SL_TEST_STAGE", stage)
+				Expect(err).To(BeNil())
+				err = os.Setenv("SL_BUILD_SESSION_ID_FILE", "")
+				Expect(err).NotTo(HaveOccurred())
+
+				err = sealights.SetApplicationStartInProcfile(stager)
+				Expect(err).To(BeNil())
+
+				packageJson, err := sealights.ReadPackageJson(stager)
+				Expect(err).To(BeNil())
+				
+				customScript := packageJson["scripts"].(map[string]interface{})["custom-script"].(string)
+				cleanResult := strings.ReplaceAll(customScript, " ", "")
+				Expect(cleanResult).To(Equal(expected))
+			})
+
+			It("should fallback to start script when custom script doesn't exist", func() {
+				err = os.WriteFile(filepath.Join(stager.BuildDir(), procfileName), []byte("web: npm run nonexistent"), 0755)
+				Expect(err).To(BeNil())
+
+				err = sealights.SetApplicationStartInPackageJson(stager, "nonexistent")
+				Expect(err).To(BeNil())
+
+				packageJson, err := sealights.ReadPackageJson(stager)
+				Expect(err).To(BeNil())
+				
+				startScript := packageJson["scripts"].(map[string]interface{})["start"].(string)
+				Expect(startScript).To(ContainSubstring("slnodejs"))
+			})
+		})
 	})
 })
diff --git a/src/nodejs/integration/sealights_test.go b/src/nodejs/integration/sealights_test.go
index cebe1e821..e6eef4cad 100644
--- a/src/nodejs/integration/sealights_test.go
+++ b/src/nodejs/integration/sealights_test.go
@@ -104,6 +104,7 @@ func testSealights(platform switchblade.Platform, fixtures string) func(*testing
 
 				pkg["scripts"] = map[string]string{
 					"start": "node server.js",
+					"start-app": "node app.js",
 				}
 
 				content, err = json.Marshal(pkg)
@@ -127,6 +128,23 @@ func testSealights(platform switchblade.Platform, fixtures string) func(*testing
 					ContainSubstring(`"start":"./node_modules/.bin/slnodejs run  --useinitialcolor true  --token token1 --buildsessionid bs1  server.js"`),
 				).WithEndpoint("/fs/package.json"))
 			})
+
+			it("modifies the defined npm command", func() {
+				deployment, _, err := platform.Deploy.
+					WithEnv(map[string]string{"SL_BUILD_SESSION_ID": "bs1"}).
+					WithServices(map[string]switchblade.Service{
+						"sealights-service": {
+							"token": "token1",
+							"npmRunScript": "start-app",
+						},
+					}).
+					Execute(name, source)
+				Expect(err).NotTo(HaveOccurred())
+
+				Eventually(deployment).Should(Serve(
+					ContainSubstring(`"start-app":"./node_modules/.bin/slnodejs run  --useinitialcolor true  --token token1 --buildsessionid bs1  app.js"`),
+				).WithEndpoint("/fs/package.json"))
+			})
 		})
 	}
 }