diff --git a/builder/config_reader.go b/builder/config_reader.go
index d719c5df8c..6ebd688d55 100644
--- a/builder/config_reader.go
+++ b/builder/config_reader.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/BurntSushi/toml"
 	"github.com/pkg/errors"
@@ -70,7 +71,25 @@ type RunImageConfig struct {
 
 // BuildConfig build image configuration
 type BuildConfig struct {
-	Image string `toml:"image"`
+	Image string           `toml:"image"`
+	Env   []BuildConfigEnv `toml:"env"`
+}
+
+type Suffix string
+
+const (
+	NONE     Suffix = ""
+	DEFAULT  Suffix = "default"
+	OVERRIDE Suffix = "override"
+	APPEND   Suffix = "append"
+	PREPEND  Suffix = "prepend"
+)
+
+type BuildConfigEnv struct {
+	Name   string `toml:"name"`
+	Value  string `toml:"value"`
+	Suffix Suffix `toml:"suffix,omitempty"`
+	Delim  string `toml:"delim,omitempty"`
 }
 
 // ReadConfig reads a builder configuration from the file path provided and returns the
@@ -162,3 +181,92 @@ func parseConfig(file *os.File) (Config, error) {
 
 	return builderConfig, nil
 }
+
+func ParseBuildConfigEnv(env []BuildConfigEnv, path string) (envMap map[string]string, warnings []string, err error) {
+	envMap = map[string]string{}
+	var appendOrPrependWithoutDelim = 0
+	for _, v := range env {
+		if name := v.Name; name == "" || len(name) == 0 {
+			return nil, nil, errors.Wrapf(errors.Errorf("env name should not be empty"), "parse contents of '%s'", path)
+		}
+		if val := v.Value; val == "" || len(val) == 0 {
+			warnings = append(warnings, fmt.Sprintf("empty value for key/name %s", style.Symbol(v.Name)))
+		}
+		suffixName, delimName, err := getBuildConfigEnvFileName(v)
+		if err != nil {
+			return envMap, warnings, err
+		}
+		if val, e := envMap[suffixName]; e {
+			warnings = append(warnings, fmt.Sprintf(errors.Errorf("overriding env with name: %s and suffix: %s from %s to %s", style.Symbol(v.Name), style.Symbol(string(v.Suffix)), style.Symbol(val), style.Symbol(v.Value)).Error(), "parse contents of '%s'", path))
+		}
+		if val, e := envMap[delimName]; e {
+			warnings = append(warnings, fmt.Sprintf(errors.Errorf("overriding env with name: %s and delim: %s from %s to %s", style.Symbol(v.Name), style.Symbol(v.Delim), style.Symbol(val), style.Symbol(v.Value)).Error(), "parse contents of '%s'", path))
+		}
+		if delim := v.Delim; (delim != "" || len(delim) != 0) && (delimName != "" || len(delimName) != 0) {
+			envMap[delimName] = delim
+		}
+		envMap[suffixName] = v.Value
+	}
+
+	for k := range envMap {
+		name, suffix, err := getFilePrefixSuffix(k)
+		if err != nil {
+			continue
+		}
+		if _, ok := envMap[name+".delim"]; (suffix == "append" || suffix == "prepend") && !ok {
+			warnings = append(warnings, fmt.Sprintf(errors.Errorf("env with name/key %s with suffix %s must to have a %s value", style.Symbol(name), style.Symbol(suffix), style.Symbol("delim")).Error(), "parse contents of '%s'", path))
+			appendOrPrependWithoutDelim++
+		}
+	}
+	if appendOrPrependWithoutDelim > 0 {
+		return envMap, warnings, errors.Errorf("error parsing [[build.env]] in file '%s'", path)
+	}
+	return envMap, warnings, err
+}
+
+func getBuildConfigEnvFileName(env BuildConfigEnv) (suffixName, delimName string, err error) {
+	suffix, err := getActionType(env.Suffix)
+	if err != nil {
+		return suffixName, delimName, err
+	}
+	if suffix == "" {
+		suffixName = env.Name
+	} else {
+		suffixName = env.Name + suffix
+	}
+	if delim := env.Delim; delim != "" || len(delim) != 0 {
+		delimName = env.Name + ".delim"
+	}
+	return suffixName, delimName, err
+}
+
+func getActionType(suffix Suffix) (suffixString string, err error) {
+	const delim = "."
+	switch suffix {
+	case NONE:
+		return "", nil
+	case DEFAULT:
+		return delim + string(DEFAULT), nil
+	case OVERRIDE:
+		return delim + string(OVERRIDE), nil
+	case APPEND:
+		return delim + string(APPEND), nil
+	case PREPEND:
+		return delim + string(PREPEND), nil
+	default:
+		return suffixString, errors.Errorf("unknown action type %s", style.Symbol(string(suffix)))
+	}
+}
+
+func getFilePrefixSuffix(filename string) (prefix, suffix string, err error) {
+	val := strings.Split(filename, ".")
+	if len(val) <= 1 {
+		return val[0], suffix, errors.Errorf("Suffix might be null")
+	}
+	if len(val) == 2 {
+		suffix = val[1]
+	} else {
+		suffix = strings.Join(val[1:], ".")
+	}
+	return val[0], suffix, err
+}
diff --git a/builder/config_reader_test.go b/builder/config_reader_test.go
index 93a1bf851d..6c5512f897 100644
--- a/builder/config_reader_test.go
+++ b/builder/config_reader_test.go
@@ -229,4 +229,111 @@ uri = "noop-buildpack.tgz"
 			h.AssertError(t, builder.ValidateConfig(config), "build.image is required")
 		})
 	})
+	when("#ParseBuildConfigEnv()", func() {
+		it("should return an error when name is not defined", func() {
+			_, _, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{
+				{
+					Name:  "",
+					Value: "vaiue",
+				},
+			}, "")
+			h.AssertNotNil(t, err)
+		})
+		it("should warn when the value is nil or empty string", func() {
+			env, warn, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{
+				{
+					Name:   "key",
+					Value:  "",
+					Suffix: "override",
+				},
+			}, "")
+
+			h.AssertNotNil(t, warn)
+			h.AssertNil(t, err)
+			h.AssertMapContains[string, string](t, env, h.NewKeyValue[string, string]("key.override", ""))
+		})
+		it("should return an error when unknown suffix is specified", func() {
+			_, _, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{
+				{
+					Name:   "key",
+					Value:  "",
+					Suffix: "invalid",
+				},
+			}, "")
+
+			h.AssertNotNil(t, err)
+		})
+		it("should override and show a warning when suffix or delim is defined multiple times", func() {
+			env, warn, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{
+				{
+					Name:   "key1",
+					Value:  "value1",
+					Suffix: "append",
+					Delim:  "%",
+				},
+				{
+					Name:   "key1",
+					Value:  "value2",
+					Suffix: "append",
+					Delim:  ",",
+				},
+				{
+					Name:   "key1",
+					Value:  "value3",
+					Suffix: "default",
+					Delim:  ";",
+				},
+				{
+					Name:   "key1",
+					Value:  "value4",
+					Suffix: "prepend",
+					Delim:  ":",
+				},
+			}, "")
+
+			h.AssertNotNil(t, warn)
+			h.AssertNil(t, err)
+			h.AssertMapContains[string, string](
+				t,
+				env,
+				h.NewKeyValue[string, string]("key1.append", "value2"),
+				h.NewKeyValue[string, string]("key1.default", "value3"),
+				h.NewKeyValue[string, string]("key1.prepend", "value4"),
+				h.NewKeyValue[string, string]("key1.delim", ":"),
+			)
+			h.AssertMapNotContains[string, string](
+				t,
+				env,
+				h.NewKeyValue[string, string]("key1.append", "value1"),
+				h.NewKeyValue[string, string]("key1.delim", "%"),
+				h.NewKeyValue[string, string]("key1.delim", ","),
+				h.NewKeyValue[string, string]("key1.delim", ";"),
+			)
+		})
+		it("should return an error when `suffix` is defined as `append` or `prepend` without a `delim`", func() {
+			_, warn, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{
+				{
+					Name:   "key",
+					Value:  "value",
+					Suffix: "append",
+				},
+			}, "")
+
+			h.AssertNotNil(t, warn)
+			h.AssertNotNil(t, err)
+		})
+		it("when suffix is NONE or omitted should default to `override`", func() {
+			env, warn, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{
+				{
+					Name:   "key",
+					Value:  "value",
+					Suffix: "",
+				},
+			}, "")
+
+			h.AssertNotNil(t, warn)
+			h.AssertNil(t, err)
+			h.AssertMapContains[string, string](t, env, h.NewKeyValue[string, string]("key", "value"))
+		})
+	})
 }
diff --git a/internal/builder/builder.go b/internal/builder/builder.go
index 51b5a4a00e..fa7dd6e9d3 100644
--- a/internal/builder/builder.go
+++ b/internal/builder/builder.go
@@ -32,6 +32,8 @@ import (
 	lifecycleplatform "github.com/buildpacks/lifecycle/platform"
 )
 
+var buildConfigDir = cnbBuildConfigDir()
+
 const (
 	packName = "Pack CLI"
 
@@ -67,6 +69,7 @@ const (
 // Builder represents a pack builder, used to build images
 type Builder struct {
 	baseImageName            string
+	buildConfigEnv           map[string]string
 	image                    imgutil.Image
 	layerWriterFactory       archive.TarWriterFactory
 	lifecycle                Lifecycle
@@ -146,6 +149,7 @@ func constructBuilder(img imgutil.Image, newName string, errOnMissingLabel bool,
 		metadata:                 metadata,
 		lifecycleDescriptor:      constructLifecycleDescriptor(metadata),
 		env:                      map[string]string{},
+		buildConfigEnv:           map[string]string{},
 		validateMixins:           true,
 		additionalBuildpacks:     *buildpack.NewModuleManager(opts.flatten, opts.depth),
 		additionalExtensions:     *buildpack.NewModuleManager(opts.flatten, opts.depth),
@@ -349,6 +353,11 @@ func (b *Builder) SetEnv(env map[string]string) {
 	b.env = env
 }
 
+// SetBuildConfigEnv sets an environment variable to a value that will take action on platform environment variables basedon filename suffix
+func (b *Builder) SetBuildConfigEnv(env map[string]string) {
+	b.buildConfigEnv = env
+}
+
 // SetOrder sets the order of the builder
 func (b *Builder) SetOrder(order dist.Order) {
 	b.order = order
@@ -525,6 +534,18 @@ func (b *Builder) Save(logger logging.Logger, creatorMetadata CreatorMetadata) e
 		return errors.Wrap(err, "adding run.tar layer")
 	}
 
+	if len(b.buildConfigEnv) > 0 {
+		logger.Debugf("Provided Build Config Environment Variables\n  %s", style.Map(b.env, "  ", "\n"))
+		buildConfigEnvTar, err := b.buildConfigEnvLayer(tmpDir, b.buildConfigEnv)
+		if err != nil {
+			return errors.Wrap(err, "retrieving build-config-env layer")
+		}
+
+		if err := b.image.AddLayer(buildConfigEnvTar); err != nil {
+			return errors.Wrap(err, "adding build-config-env layer")
+		}
+	}
+
 	if len(b.env) > 0 {
 		logger.Debugf("Provided Environment Variables\n  %s", style.Map(b.env, "  ", "\n"))
 	}
@@ -903,7 +924,7 @@ func (b *Builder) defaultDirsLayer(dest string) (string, error) {
 	}
 
 	// can't use filepath.Join(), to ensure Windows doesn't transform it to Windows join
-	for _, path := range []string{cnbDir, dist.BuildpacksDir, dist.ExtensionsDir, platformDir, platformDir + "/env"} {
+	for _, path := range []string{cnbDir, dist.BuildpacksDir, dist.ExtensionsDir, platformDir, platformDir + "/env", buildConfigDir, buildConfigDir + "/env"} {
 		if err := lw.WriteHeader(b.rootOwnedDir(path, ts)); err != nil {
 			return "", errors.Wrapf(err, "creating %s dir in layer", style.Symbol(path))
 		}
@@ -1102,6 +1123,31 @@ func (b *Builder) envLayer(dest string, env map[string]string) (string, error) {
 	return fh.Name(), nil
 }
 
+func (b *Builder) buildConfigEnvLayer(dest string, env map[string]string) (string, error) {
+	fh, err := os.Create(filepath.Join(dest, "build-config-env.tar"))
+	if err != nil {
+		return "", err
+	}
+	defer fh.Close()
+	lw := b.layerWriterFactory.NewWriter(fh)
+	defer lw.Close()
+	for k, v := range env {
+		if err := lw.WriteHeader(&tar.Header{
+			Name:    path.Join(cnbBuildConfigDir(), "env", k),
+			Size:    int64(len(v)),
+			Mode:    0644,
+			ModTime: archive.NormalizedDateTime,
+		}); err != nil {
+			return "", err
+		}
+		if _, err := lw.Write([]byte(v)); err != nil {
+			return "", err
+		}
+	}
+
+	return fh.Name(), nil
+}
+
 func (b *Builder) whiteoutLayer(tmpDir string, i int, bpInfo dist.ModuleInfo) (string, error) {
 	bpWhiteoutsTmpDir := filepath.Join(tmpDir, strconv.Itoa(i)+"_whiteouts")
 	if err := os.MkdirAll(bpWhiteoutsTmpDir, os.ModePerm); err != nil {
@@ -1257,3 +1303,11 @@ func (e errModuleTar) Info() dist.ModuleInfo {
 func (e errModuleTar) Path() string {
 	return ""
 }
+
+func cnbBuildConfigDir() string {
+	if env, ok := os.LookupEnv("CNB_BUILD_CONFIG_DIR"); ok {
+		return env
+	}
+
+	return "/cnb/build-config"
+}
diff --git a/internal/builder/builder_test.go b/internal/builder/builder_test.go
index 13a958c72e..37124533da 100644
--- a/internal/builder/builder_test.go
+++ b/internal/builder/builder_test.go
@@ -384,6 +384,19 @@ func testBuilder(t *testing.T, when spec.G, it spec.S) {
 				)
 			})
 
+			it("creates the build-config dir", func() {
+				h.AssertNil(t, subject.Save(logger, builder.CreatorMetadata{}))
+				h.AssertEq(t, baseImage.IsSaved(), true)
+
+				layerTar, err := baseImage.FindLayerWithPath("/cnb/build-config")
+				h.AssertNil(t, err)
+				h.AssertOnTarEntry(t, layerTar, "/cnb/build-config",
+					h.IsDirectory(),
+					h.HasOwnerAndGroup(0, 0),
+					h.HasFileMode(0755),
+					h.HasModTime(archive.NormalizedDateTime),
+				)
+			})
 			it("creates the buildpacks dir", func() {
 				h.AssertNil(t, subject.Save(logger, builder.CreatorMetadata{}))
 				h.AssertEq(t, baseImage.IsSaved(), true)
@@ -1607,6 +1620,71 @@ func testBuilder(t *testing.T, when spec.G, it spec.S) {
 			})
 		})
 
+		when("when CNB_BUILD_CONFIG_DIR is defined", func() {
+			var buildConfigEnvName = "CNB_BUILD_CONFIG_DIR"
+			var buildConfigEnvValue = "/cnb/dup-build-config-dir"
+			it.Before(func() {
+				os.Setenv(buildConfigEnvName, buildConfigEnvValue)
+				subject.SetBuildConfigEnv(map[string]string{
+					"SOME_KEY":         "some-val",
+					"OTHER_KEY.append": "other-val",
+					"OTHER_KEY.delim":  ":",
+				})
+				h.AssertNil(t, subject.Save(logger, builder.CreatorMetadata{}))
+				h.AssertEq(t, baseImage.IsSaved(), true)
+			})
+			it.After(func() {
+				os.Unsetenv(buildConfigEnvName)
+			})
+
+			it("adds the env vars as files to the image", func() {
+				layerTar, err := baseImage.FindLayerWithPath(buildConfigEnvValue + "/env/SOME_KEY")
+				h.AssertNil(t, err)
+				h.AssertOnTarEntry(t, layerTar, buildConfigEnvValue+"/env/SOME_KEY",
+					h.ContentEquals(`some-val`),
+					h.HasModTime(archive.NormalizedDateTime),
+				)
+				h.AssertOnTarEntry(t, layerTar, buildConfigEnvValue+"/env/OTHER_KEY.append",
+					h.ContentEquals(`other-val`),
+					h.HasModTime(archive.NormalizedDateTime),
+				)
+				h.AssertOnTarEntry(t, layerTar, buildConfigEnvValue+"/env/OTHER_KEY.delim",
+					h.ContentEquals(`:`),
+					h.HasModTime(archive.NormalizedDateTime),
+				)
+			})
+		})
+
+		when("#SetBuildConfigEnv", func() {
+			it.Before(func() {
+				os.Unsetenv("CNB_BUILD_CONFIG_DIR")
+				subject.SetBuildConfigEnv(map[string]string{
+					"SOME_KEY":         "some-val",
+					"OTHER_KEY.append": "other-val",
+					"OTHER_KEY.delim":  ":",
+				})
+				h.AssertNil(t, subject.Save(logger, builder.CreatorMetadata{}))
+				h.AssertEq(t, baseImage.IsSaved(), true)
+			})
+
+			it("adds the env vars as files to the image", func() {
+				layerTar, err := baseImage.FindLayerWithPath("/cnb/build-config/env/SOME_KEY")
+				h.AssertNil(t, err)
+				h.AssertOnTarEntry(t, layerTar, "/cnb/build-config/env/SOME_KEY",
+					h.ContentEquals(`some-val`),
+					h.HasModTime(archive.NormalizedDateTime),
+				)
+				h.AssertOnTarEntry(t, layerTar, "/cnb/build-config/env/OTHER_KEY.append",
+					h.ContentEquals(`other-val`),
+					h.HasModTime(archive.NormalizedDateTime),
+				)
+				h.AssertOnTarEntry(t, layerTar, "/cnb/build-config/env/OTHER_KEY.delim",
+					h.ContentEquals(`:`),
+					h.HasModTime(archive.NormalizedDateTime),
+				)
+			})
+		})
+
 		when("#SetEnv", func() {
 			it.Before(func() {
 				subject.SetEnv(map[string]string{
diff --git a/internal/commands/builder_create.go b/internal/commands/builder_create.go
index 1b0d709895..c3c1ccb90b 100644
--- a/internal/commands/builder_create.go
+++ b/internal/commands/builder_create.go
@@ -75,9 +75,18 @@ Creating a custom builder allows you to control what buildpacks are used and wha
 				return errors.Wrap(err, "getting absolute path for config")
 			}
 
+			envMap, warnings, err := builder.ParseBuildConfigEnv(builderConfig.Build.Env, flags.BuilderTomlPath)
+			for _, v := range warnings {
+				logger.Warn(v)
+			}
+			if err != nil {
+				return err
+			}
+
 			imageName := args[0]
 			if err := pack.CreateBuilder(cmd.Context(), client.CreateBuilderOptions{
 				RelativeBaseDir: relativeBaseDir,
+				BuildConfigEnv:  envMap,
 				BuilderName:     imageName,
 				Config:          builderConfig,
 				Publish:         flags.Publish,
diff --git a/internal/commands/builder_create_test.go b/internal/commands/builder_create_test.go
index 12c89465f4..4ddf115b32 100644
--- a/internal/commands/builder_create_test.go
+++ b/internal/commands/builder_create_test.go
@@ -13,6 +13,7 @@ import (
 	"github.com/sclevine/spec/report"
 	"github.com/spf13/cobra"
 
+	"github.com/buildpacks/pack/builder"
 	"github.com/buildpacks/pack/internal/commands"
 	"github.com/buildpacks/pack/internal/commands/testmocks"
 	"github.com/buildpacks/pack/internal/config"
@@ -47,6 +48,110 @@ const validConfigWithExtensions = `
 
 `
 
+var BuildConfigEnvSuffixNone = builder.BuildConfigEnv{
+	Name:  "suffixNone",
+	Value: "suffixNoneValue",
+}
+
+var BuildConfigEnvSuffixNoneWithEmptySuffix = builder.BuildConfigEnv{
+	Name:   "suffixNoneWithEmptySuffix",
+	Value:  "suffixNoneWithEmptySuffixValue",
+	Suffix: "",
+}
+
+var BuildConfigEnvSuffixDefault = builder.BuildConfigEnv{
+	Name:   "suffixDefault",
+	Value:  "suffixDefaultValue",
+	Suffix: "default",
+}
+
+var BuildConfigEnvSuffixOverride = builder.BuildConfigEnv{
+	Name:   "suffixOverride",
+	Value:  "suffixOverrideValue",
+	Suffix: "override",
+}
+
+var BuildConfigEnvSuffixAppend = builder.BuildConfigEnv{
+	Name:   "suffixAppend",
+	Value:  "suffixAppendValue",
+	Suffix: "append",
+	Delim:  ":",
+}
+
+var BuildConfigEnvSuffixPrepend = builder.BuildConfigEnv{
+	Name:   "suffixPrepend",
+	Value:  "suffixPrependValue",
+	Suffix: "prepend",
+	Delim:  ":",
+}
+
+var BuildConfigEnvDelimWithoutSuffix = builder.BuildConfigEnv{
+	Name:  "delimWithoutSuffix",
+	Delim: ":",
+}
+
+var BuildConfigEnvSuffixUnknown = builder.BuildConfigEnv{
+	Name:   "suffixUnknown",
+	Value:  "suffixUnknownValue",
+	Suffix: "unknown",
+}
+
+var BuildConfigEnvSuffixMultiple = []builder.BuildConfigEnv{
+	{
+		Name:   "MY_VAR",
+		Value:  "suffixAppendValueValue",
+		Suffix: "append",
+		Delim:  ";",
+	},
+	{
+		Name:   "MY_VAR",
+		Value:  "suffixDefaultValue",
+		Suffix: "default",
+		Delim:  "%",
+	},
+	{
+		Name:   "MY_VAR",
+		Value:  "suffixPrependValue",
+		Suffix: "prepend",
+		Delim:  ":",
+	},
+}
+
+var BuildConfigEnvEmptyValue = builder.BuildConfigEnv{
+	Name:  "warning",
+	Value: "",
+}
+
+var BuildConfigEnvEmptyName = builder.BuildConfigEnv{
+	Name:   "",
+	Value:  "suffixUnknownValue",
+	Suffix: "default",
+}
+
+var BuildConfigEnvSuffixPrependWithoutDelim = builder.BuildConfigEnv{
+	Name:   "suffixPrepend",
+	Value:  "suffixPrependValue",
+	Suffix: "prepend",
+}
+
+var BuildConfigEnvDelimWithoutSuffixAppendOrPrepend = builder.BuildConfigEnv{
+	Name:  "delimWithoutActionAppendOrPrepend",
+	Value: "some-value",
+	Delim: ":",
+}
+
+var BuildConfigEnvDelimWithSameSuffixAndName = []builder.BuildConfigEnv{
+	{
+		Name:   "MY_VAR",
+		Value:  "some-value",
+		Suffix: "",
+	},
+	{
+		Name:  "MY_VAR",
+		Value: "some-value",
+	},
+}
+
 func TestCreateCommand(t *testing.T) {
 	color.Disable(true)
 	defer color.Disable(false)
@@ -171,6 +276,115 @@ func testCreateCommand(t *testing.T, when spec.G, it spec.S) {
 			})
 		})
 
+		when("#ParseBuildpackConfigEnv", func() {
+			it("should create envMap as expected when suffix is omitted", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{BuildConfigEnvSuffixNone}, "")
+				h.AssertEq(t, envMap, map[string]string{
+					BuildConfigEnvSuffixNone.Name: BuildConfigEnvSuffixNone.Value,
+				})
+				h.AssertEq(t, len(warnings), 0)
+				h.AssertNil(t, err)
+			})
+			it("should create envMap as expected when suffix is empty string", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{BuildConfigEnvSuffixNoneWithEmptySuffix}, "")
+				h.AssertEq(t, envMap, map[string]string{
+					BuildConfigEnvSuffixNoneWithEmptySuffix.Name: BuildConfigEnvSuffixNoneWithEmptySuffix.Value,
+				})
+				h.AssertEq(t, len(warnings), 0)
+				h.AssertNil(t, err)
+			})
+			it("should create envMap as expected when suffix is `default`", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{BuildConfigEnvSuffixDefault}, "")
+				h.AssertEq(t, envMap, map[string]string{
+					BuildConfigEnvSuffixDefault.Name + "." + string(BuildConfigEnvSuffixDefault.Suffix): BuildConfigEnvSuffixDefault.Value,
+				})
+				h.AssertEq(t, len(warnings), 0)
+				h.AssertNil(t, err)
+			})
+			it("should create envMap as expected when suffix is `override`", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{BuildConfigEnvSuffixOverride}, "")
+				h.AssertEq(t, envMap, map[string]string{
+					BuildConfigEnvSuffixOverride.Name + "." + string(BuildConfigEnvSuffixOverride.Suffix): BuildConfigEnvSuffixOverride.Value,
+				})
+				h.AssertEq(t, len(warnings), 0)
+				h.AssertNil(t, err)
+			})
+			it("should create envMap as expected when suffix is `append`", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{BuildConfigEnvSuffixAppend}, "")
+				h.AssertEq(t, envMap, map[string]string{
+					BuildConfigEnvSuffixAppend.Name + "." + string(BuildConfigEnvSuffixAppend.Suffix): BuildConfigEnvSuffixAppend.Value,
+					BuildConfigEnvSuffixAppend.Name + ".delim":                                        BuildConfigEnvSuffixAppend.Delim,
+				})
+				h.AssertEq(t, len(warnings), 0)
+				h.AssertNil(t, err)
+			})
+			it("should create envMap as expected when suffix is `prepend`", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{BuildConfigEnvSuffixPrepend}, "")
+				h.AssertEq(t, envMap, map[string]string{
+					BuildConfigEnvSuffixPrepend.Name + "." + string(BuildConfigEnvSuffixPrepend.Suffix): BuildConfigEnvSuffixPrepend.Value,
+					BuildConfigEnvSuffixPrepend.Name + ".delim":                                         BuildConfigEnvSuffixPrepend.Delim,
+				})
+				h.AssertEq(t, len(warnings), 0)
+				h.AssertNil(t, err)
+			})
+			it("should create envMap as expected when delim is specified", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{BuildConfigEnvDelimWithoutSuffix}, "")
+				h.AssertEq(t, envMap, map[string]string{
+					BuildConfigEnvDelimWithoutSuffix.Name:            BuildConfigEnvDelimWithoutSuffix.Value,
+					BuildConfigEnvDelimWithoutSuffix.Name + ".delim": BuildConfigEnvDelimWithoutSuffix.Delim,
+				})
+				h.AssertNotEq(t, len(warnings), 0)
+				h.AssertNil(t, err)
+			})
+			it("should create envMap with a warning when `value` is empty", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{BuildConfigEnvEmptyValue}, "")
+				h.AssertEq(t, envMap, map[string]string{
+					BuildConfigEnvEmptyValue.Name: BuildConfigEnvEmptyValue.Value,
+				})
+				h.AssertNotEq(t, len(warnings), 0)
+				h.AssertNil(t, err)
+			})
+			it("should return an error when `name` is empty", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{BuildConfigEnvEmptyName}, "")
+				h.AssertEq(t, envMap, map[string]string(nil))
+				h.AssertEq(t, len(warnings), 0)
+				h.AssertNotNil(t, err)
+			})
+			it("should return warnings when `apprend` or `prepend` is used without `delim`", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{BuildConfigEnvSuffixPrependWithoutDelim}, "")
+				h.AssertEq(t, envMap, map[string]string{
+					BuildConfigEnvSuffixPrependWithoutDelim.Name + "." + string(BuildConfigEnvSuffixPrependWithoutDelim.Suffix): BuildConfigEnvSuffixPrependWithoutDelim.Value,
+				})
+				h.AssertNotEq(t, len(warnings), 0)
+				h.AssertNotNil(t, err)
+			})
+			it("should return an error when unknown `suffix` is used", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv([]builder.BuildConfigEnv{BuildConfigEnvSuffixUnknown}, "")
+				h.AssertEq(t, envMap, map[string]string{})
+				h.AssertEq(t, len(warnings), 0)
+				h.AssertNotNil(t, err)
+			})
+			it("should override with the last specified delim when `[[build.env]]` has multiple delims with same `name` with a `append` or `prepend` suffix", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv(BuildConfigEnvSuffixMultiple, "")
+				h.AssertEq(t, envMap, map[string]string{
+					BuildConfigEnvSuffixMultiple[0].Name + "." + string(BuildConfigEnvSuffixMultiple[0].Suffix): BuildConfigEnvSuffixMultiple[0].Value,
+					BuildConfigEnvSuffixMultiple[1].Name + "." + string(BuildConfigEnvSuffixMultiple[1].Suffix): BuildConfigEnvSuffixMultiple[1].Value,
+					BuildConfigEnvSuffixMultiple[2].Name + "." + string(BuildConfigEnvSuffixMultiple[2].Suffix): BuildConfigEnvSuffixMultiple[2].Value,
+					BuildConfigEnvSuffixMultiple[2].Name + ".delim":                                             BuildConfigEnvSuffixMultiple[2].Delim,
+				})
+				h.AssertNotEq(t, len(warnings), 0)
+				h.AssertNil(t, err)
+			})
+			it("should override `value` with the last read value when a `[[build.env]]` has same `name` with same `suffix`", func() {
+				envMap, warnings, err := builder.ParseBuildConfigEnv(BuildConfigEnvDelimWithSameSuffixAndName, "")
+				h.AssertEq(t, envMap, map[string]string{
+					BuildConfigEnvDelimWithSameSuffixAndName[1].Name: BuildConfigEnvDelimWithSameSuffixAndName[1].Value,
+				})
+				h.AssertNotEq(t, len(warnings), 0)
+				h.AssertNil(t, err)
+			})
+		})
+
 		when("no config provided", func() {
 			it("errors with a descriptive message", func() {
 				command.SetArgs([]string{
diff --git a/pkg/client/create_builder.go b/pkg/client/create_builder.go
index dc03d73d6b..b697313b33 100644
--- a/pkg/client/create_builder.go
+++ b/pkg/client/create_builder.go
@@ -29,6 +29,9 @@ type CreateBuilderOptions struct {
 	// Name of the builder.
 	BuilderName string
 
+	// BuildConfigEnv for Builder
+	BuildConfigEnv map[string]string
+
 	// Configuration that defines the functionality a builder provides.
 	Config pubbldr.Config
 
@@ -79,6 +82,7 @@ func (c *Client) CreateBuilder(ctx context.Context, opts CreateBuilderOptions) e
 		bldr.SetStack(opts.Config.Stack)
 	}
 	bldr.SetRunImage(opts.Config.Run)
+	bldr.SetBuildConfigEnv(opts.BuildConfigEnv)
 
 	return bldr.Save(c.logger, builder.CreatorMetadata{Version: c.version})
 }
@@ -191,6 +195,7 @@ func (c *Client) createBaseBuilder(ctx context.Context, opts CreateBuilderOption
 	}
 
 	bldr.SetLifecycle(lifecycle)
+	bldr.SetBuildConfigEnv(opts.BuildConfigEnv)
 
 	return bldr, nil
 }
diff --git a/testhelpers/testhelpers.go b/testhelpers/testhelpers.go
index 7868691a3c..3eeb4b6431 100644
--- a/testhelpers/testhelpers.go
+++ b/testhelpers/testhelpers.go
@@ -179,6 +179,33 @@ func AssertNotContains(t *testing.T, actual, expected string) {
 	}
 }
 
+type KeyValue[k comparable, v any] struct {
+	key   k
+	value v
+}
+
+func NewKeyValue[k comparable, v any](key k, value v) KeyValue[k, v] {
+	return KeyValue[k, v]{key: key, value: value}
+}
+
+func AssertMapContains[key comparable, value any](t *testing.T, actual map[key]value, expected ...KeyValue[key, value]) {
+	t.Helper()
+	for _, i := range expected {
+		if v, ok := actual[i.key]; !ok || !reflect.DeepEqual(v, i.value) {
+			t.Fatalf("Expected %s to contain elements %s", reflect.ValueOf(actual), reflect.ValueOf(expected))
+		}
+	}
+}
+
+func AssertMapNotContains[key comparable, value any](t *testing.T, actual map[key]value, expected ...KeyValue[key, value]) {
+	t.Helper()
+	for _, i := range expected {
+		if v, ok := actual[i.key]; ok && reflect.DeepEqual(v, i.value) {
+			t.Fatalf("Expected %s to not contain elements %s", reflect.ValueOf(actual), reflect.ValueOf(expected))
+		}
+	}
+}
+
 func AssertSliceContains(t *testing.T, slice []string, expected ...string) {
 	t.Helper()
 	_, missing, _ := stringset.Compare(slice, expected)