diff --git a/assets/js/components/Config/LmAdvancedModal.vue b/assets/js/components/Config/LmAdvancedModal.vue
index bbac5bed44..d952ac8b30 100644
--- a/assets/js/components/Config/LmAdvancedModal.vue
+++ b/assets/js/components/Config/LmAdvancedModal.vue
@@ -68,6 +68,43 @@
 				</select>
 			</FormRow>
 
+			<!-- custom: home consumption forecast for the optimizer, see core/site_load_weekday.go -->
+			<FormRow
+				id="lmAdvanced-homeWeekday"
+				:label="$t('config.lmadvanced.homeWeekdayLabel')"
+				:help="$t('config.lmadvanced.homeWeekdayHelp')"
+			>
+				<select
+					id="lmAdvanced-homeWeekday"
+					v-model.number="values.homeWeekday"
+					class="form-select"
+					data-testid="lmadvanced-homeWeekday"
+				>
+					<option :value="0">{{ $t("config.lmadvanced.homeWeekdayOff") }}</option>
+					<option :value="1">{{ $t("config.lmadvanced.homeWeekdayOn") }}</option>
+				</select>
+			</FormRow>
+			<FormRow
+				id="lmAdvanced-percentile"
+				:label="$t('config.lmadvanced.percentileLabel')"
+				:help="$t('config.lmadvanced.percentileHelp')"
+			>
+				<select
+					id="lmAdvanced-percentile"
+					v-model.number="percentile"
+					class="form-select"
+					data-testid="lmadvanced-percentile"
+				>
+					<option v-for="p in percentiles" :key="p" :value="p">
+						{{
+							p
+								? $t("config.lmadvanced.percentileValue", { percentile: p })
+								: $t("config.lmadvanced.percentileAverage")
+						}}
+					</option>
+				</select>
+			</FormRow>
+
 			<div class="mt-4 d-flex justify-content-between gap-2 flex-column flex-sm-row">
 				<button
 					type="button"
@@ -80,7 +117,7 @@
 				<button
 					type="submit"
 					class="btn btn-primary order-1 order-sm-2 flex-grow-1 flex-sm-grow-0 px-4"
-					:disabled="saving || (!changed.length && !circuitChanged)"
+					:disabled="saving || (!changed.length && !circuitChanged && !percentileChanged)"
 				>
 					<span
 						v-if="saving"
@@ -137,12 +174,24 @@ export default {
 			initial: {},
 			circuit: "",
 			initialCircuit: "",
+			percentile: 0,
+			initialPercentile: 0,
 		};
 	},
 	computed: {
 		numberFields() {
 			return FIELDS;
 		},
+		percentiles() {
+			// upstream profilePercentile in %, 0 = average
+			const res = [0, 60, 70, 80, 90];
+			return res.includes(this.initialPercentile)
+				? res
+				: [...res, this.initialPercentile].sort((a, b) => a - b);
+		},
+		percentileChanged() {
+			return this.percentile !== this.initialPercentile;
+		},
 		circuitChanged() {
 			return this.circuit !== this.initialCircuit;
 		},
@@ -168,6 +217,7 @@ export default {
 			const values = {};
 			FIELDS.forEach((f) => (values[f.name] = state[f.name] ?? f.default));
 			values.phases = state.phases ?? 3;
+			values.homeWeekday = state.homeWeekday ? 1 : 0;
 
 			this.saving = false;
 			this.error = "";
@@ -175,6 +225,8 @@ export default {
 			this.initial = { ...values };
 			this.circuit = store.state?.lmOff?.circuit || "";
 			this.initialCircuit = this.circuit;
+			this.percentile = store.state?.profilePercentile ?? 0;
+			this.initialPercentile = this.percentile;
 		},
 		invalidField() {
 			return FIELDS.find((f) => {
@@ -210,6 +262,13 @@ export default {
 						await api.delete("lmcircuit");
 					}
 				}
+				if (this.percentileChanged) {
+					if (this.percentile) {
+						await api.post(`profilepercentile/${this.percentile}`);
+					} else {
+						await api.delete("profilepercentile");
+					}
+				}
 				for (const name of this.changed) {
 					await api.post(`lmadvanced/${name}/${this.values[name]}`);
 				}
diff --git a/assets/js/types/evcc.ts b/assets/js/types/evcc.ts
index 930b1f0b68..94b6a7f23b 100644
--- a/assets/js/types/evcc.ts
+++ b/assets/js/types/evcc.ts
@@ -177,6 +177,8 @@ export interface LmAdvanced {
   peakFreeze: number;
   /** Allowed grid draw at most this multiple of the peak limit. */
   peakCap: number;
+  /** Home consumption forecast per weekday. */
+  homeWeekday?: boolean;
   /** Cycles after which a load ignoring its limit is no longer counted on, 0 = off. */
   followCycles: number;
   gridChargeWindow: number;
diff --git a/core/lm/README.md b/core/lm/README.md
index 09b8488d90..2d72531e22 100644
--- a/core/lm/README.md
+++ b/core/lm/README.md
@@ -131,6 +131,7 @@ Keep these in mind when merging a new evcc version:
 | `core/site/api.go` | embeds `CustomAPI`, one line |
 | `api/globalconfig/types.go`, `tariff/tariffs.go`, `cmd/setup.go`, `server/http_config_device_handler.go` | `feedInEeg` tariff role: ref field, `Used`/`IsConfigured`, one `configureTariff` call, cleared on delete |
 | `assets/js/components/Config/TariffModal.vue` | `feedInEeg` offers the price templates |
+| `core/site_load_predictor.go` | `homeProfileByWeekday` call in `homeProfile` |
 | `core/site_optimizer.go` | `applyLmOptimizerInputs` where the optimizer request is assembled |
 | `server/http.go` | merges `customSiteRoutes`, one loop |
 | `assets/js/views/Battery.vue` | mounts the new cards, profile selection at the bottom |
@@ -263,6 +264,20 @@ configured limits (or the raised one of follow the peak). Survives a restart
 Circuit limits changed at runtime are published with their configured values
 in `lmOff.limits`, so the overview shows them.
 
+## Home consumption forecast per weekday
+
+Lastmanagement-Details → Erweitert → *Verbrauchsprognose*. evcc forecasts the
+home base load for the optimizer from the average of the last 28 days per
+quarter hour. *Nach Wochentag* takes each forecast day from the same weekday of
+the last 8 weeks instead, so weekends and working days keep their own shape; a
+weekday without complete data falls back to the average. Stored as
+`homeWeekday` in the advanced settings, see `core/site_load_weekday.go`, one
+call in `homeProfile` (`core/site_load_predictor.go`).
+
+*Sicherheitszuschlag Verbrauch* sets upstream's `profilePercentile` (API only
+upstream): a higher percentile per quarter hour instead of the mean, for both
+profiles and the heating devices' profiles.
+
 ## Capacity tariff
 
 Lastmanagement-Details → Leistungstarif. The month's highest quarter hour is
diff --git a/core/metrics/profile_custom.go b/core/metrics/profile_custom.go
new file mode 100644
index 0000000000..52ae6c6a1e
--- /dev/null
+++ b/core/metrics/profile_custom.go
@@ -0,0 +1,12 @@
+package metrics
+
+// Custom extension: the weekday profile over a chosen history, for the home
+// forecast per weekday, see core/site_load_weekday.go.
+
+import "time"
+
+// EnergyProfileWeekdaySince is EnergyProfileWeekday from the given time on
+func (c *Collector) EnergyProfileWeekdaySince(weekday time.Weekday, from time.Time) (*[96]float64, error) {
+	wd := int(weekday)
+	return energyProfileFiltered(c.entity, from, &wd, profilePercentile())
+}
diff --git a/core/site_lm_advanced.go b/core/site_lm_advanced.go
index d2418511df..4620303049 100644
--- a/core/site_lm_advanced.go
+++ b/core/site_lm_advanced.go
@@ -27,6 +27,8 @@ type lmAdvanced struct {
 	FollowCycles *float64 `json:"followCycles,omitempty"`
 	// hours the optimizer may take to reach the stop soc of soc-based grid charging
 	GridChargeWindow *float64 `json:"gridChargeWindow,omitempty"`
+	// home consumption forecast per weekday, 1 = on, see site_load_weekday.go
+	HomeWeekday *float64 `json:"homeWeekday,omitempty"`
 }
 
 // lmAdvancedState is what the ui shows: the values in effect
@@ -40,6 +42,7 @@ type lmAdvancedState struct {
 	PeakCap          float64 `json:"peakCap"`
 	FollowCycles     int     `json:"followCycles"`
 	GridChargeWindow float64 `json:"gridChargeWindow"`
+	HomeWeekday      bool    `json:"homeWeekday"`
 }
 
 // lmAdvancedLimit is a setting's valid range
@@ -58,6 +61,7 @@ var lmAdvancedLimits = map[string]lmAdvancedLimit{
 	"peakCap":          {1, 10, false},
 	"followCycles":     {0, 20, true},
 	"gridChargeWindow": {1, 24, true},
+	"homeWeekday":      {0, 1, true},
 }
 
 // restoreLmAdvanced restores the persisted advanced settings
@@ -98,6 +102,7 @@ func (site *Site) publishLmAdvanced() {
 		PeakCap:          site.peakCap(),
 		FollowCycles:     site.lmFollowCycles(),
 		GridChargeWindow: site.gridChargeWindow().Hours(),
+		HomeWeekday:      site.homeWeekday(),
 	})
 }
 
@@ -148,6 +153,8 @@ func (site *Site) SetLmAdvanced(name string, value float64) error {
 		s.adv.FollowCycles = &v
 	case "gridChargeWindow":
 		s.adv.GridChargeWindow = &v
+	case "homeWeekday":
+		s.adv.HomeWeekday = &v
 	}
 	adv := s.adv
 	s.advMu.Unlock()
@@ -161,6 +168,9 @@ func (site *Site) SetLmAdvanced(name string, value float64) error {
 	if name == "timeout" {
 		lm.SetTimeout(site.lmTimeout())
 	}
+	if name == "homeWeekday" {
+		site.Optimize() // the home demand forecast changed
+	}
 
 	site.publishLmAdvanced()
 
diff --git a/core/site_load_predictor.go b/core/site_load_predictor.go
index d284c3ba17..baf933b773 100644
--- a/core/site_load_predictor.go
+++ b/core/site_load_predictor.go
@@ -17,6 +17,11 @@ import (
 func (site *Site) homeProfile(minLen int) ([]float64, error) {
 	col := site.collectors[metrics.Home]
 
+	// custom: per weekday, see core/site_load_weekday.go
+	if site.homeWeekday() {
+		return site.homeProfileByWeekday(col, minLen)
+	}
+
 	base, err := col.EnergyProfile(now.BeginningOfDay().AddDate(0, 0, -28))
 	if err != nil {
 		return nil, err
diff --git a/core/site_load_weekday.go b/core/site_load_weekday.go
new file mode 100644
index 0000000000..f299d75e31
--- /dev/null
+++ b/core/site_load_weekday.go
@@ -0,0 +1,77 @@
+package core
+
+// Custom extension: home consumption forecast per weekday. evcc forecasts the
+// home base load for the optimizer from the average of the last 28 days per
+// time of day, so weekends and working days blur into one profile. With it on
+// (Lastmanagement-Details → Erweitert), each forecast day takes the same weekday
+// of the last 8 weeks instead. The percentile set there (upstream
+// profilePercentile) applies to it like to the regular profile. A weekday
+// without complete data yet falls back to the regular profile.
+
+import (
+	"errors"
+	"time"
+
+	"github.com/evcc-io/evcc/core/metrics"
+	"github.com/evcc-io/evcc/tariff"
+	"github.com/jinzhu/now"
+)
+
+// homeWeekdayWeeks is how many weeks back the weekday profiles reach
+const homeWeekdayWeeks = 8
+
+// homeWeekday reports whether the home forecast is taken per weekday
+func (site *Site) homeWeekday() bool {
+	v := site.advanced().HomeWeekday
+	return v != nil && *v == 1
+}
+
+// homeProfileByWeekday returns the home base load in Wh for minLen 15min slots
+// starting now, each day from the profile of its weekday
+func (site *Site) homeProfileByWeekday(col *metrics.Collector, minLen int) ([]float64, error) {
+	today := now.BeginningOfDay()
+	from := today.AddDate(0, 0, -7*homeWeekdayWeeks)
+	first := int(time.Now().Truncate(tariff.SlotDuration).Sub(today) / tariff.SlotDuration)
+
+	var fallback *[96]float64
+	profiles := make(map[time.Weekday]*[96]float64)
+
+	res := make([]float64, minLen)
+	for i := range res {
+		slot := first + i
+		weekday := today.AddDate(0, 0, slot/96).Weekday()
+
+		p, ok := profiles[weekday]
+		if !ok {
+			var err error
+			p, err = col.EnergyProfileWeekdaySince(weekday, from)
+			if err != nil && !errors.Is(err, metrics.ErrIncomplete) {
+				return nil, err
+			}
+
+			if err != nil || profileEmpty(p) {
+				if fallback == nil {
+					if fallback, err = col.EnergyProfile(today.AddDate(0, 0, -28)); err != nil {
+						return nil, err
+					}
+				}
+				p = fallback
+			}
+
+			profiles[weekday] = p
+		}
+
+		res[i] = p[slot%96] * 1e3
+	}
+
+	return res, nil
+}
+
+func profileEmpty(p *[96]float64) bool {
+	for _, v := range p {
+		if v != 0 {
+			return false
+		}
+	}
+	return true
+}
diff --git a/core/site_load_weekday_test.go b/core/site_load_weekday_test.go
new file mode 100644
index 0000000000..3e4838c469
--- /dev/null
+++ b/core/site_load_weekday_test.go
@@ -0,0 +1,105 @@
+package core
+
+import (
+	"testing"
+	"time"
+
+	"github.com/evcc-io/evcc/core/metrics"
+	"github.com/evcc-io/evcc/db"
+	"github.com/evcc-io/evcc/tariff"
+	"github.com/evcc-io/evcc/util"
+	"github.com/jinzhu/now"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// seedHome writes the home energy of every slot of the last days, kWh per slot by weekday
+func seedHome(t *testing.T, days int, kwh func(time.Weekday) float64) *metrics.Collector {
+	t.Helper()
+	require.NoError(t, db.NewInstance("sqlite", ":memory:"))
+	require.NoError(t, metrics.SetupSchema())
+
+	col, err := metrics.NewCollector(metrics.Home, metrics.Home, "")
+	require.NoError(t, err)
+
+	var id int
+	require.NoError(t, db.Instance.Raw(`SELECT id FROM entities WHERE name = ?`, metrics.Home).Scan(&id).Error)
+
+	for day := -days; day < 0; day++ {
+		base := now.BeginningOfDay().AddDate(0, 0, day)
+		v := kwh(base.Weekday())
+		if v == 0 {
+			continue
+		}
+		for slot := range 96 {
+			ts := base.Add(time.Duration(slot) * tariff.SlotDuration).Unix()
+			require.NoError(t, db.Instance.Exec(`INSERT INTO meters (meter, ts, energy) VALUES (?, ?, ?)`, id, ts, v).Error)
+		}
+	}
+
+	return col
+}
+
+func TestHomeProfileByWeekday(t *testing.T) {
+	today := time.Now().Weekday()
+	tomorrow := (today + 1) % 7
+
+	col := seedHome(t, 56, func(wd time.Weekday) float64 {
+		switch wd {
+		case today:
+			return 2
+		case tomorrow:
+			return 3
+		}
+		return 1
+	})
+
+	site := &Site{log: util.NewLogger("test")}
+	first := int(time.Now().Truncate(tariff.SlotDuration).Sub(now.BeginningOfDay()) / tariff.SlotDuration)
+
+	res, err := site.homeProfileByWeekday(col, 2*96)
+	require.NoError(t, err)
+
+	for i, v := range res {
+		want := 2000.0
+		if (first+i)/96 == 1 {
+			want = 3000
+		}
+		if (first+i)/96 == 2 {
+			want = 1000
+		}
+		assert.Equal(t, want, v, "slot %d", i)
+	}
+}
+
+// A weekday without data takes the regular 28 day profile.
+func TestHomeProfileByWeekdayFallback(t *testing.T) {
+	today := time.Now().Weekday()
+
+	col := seedHome(t, 28, func(wd time.Weekday) float64 {
+		if wd == today {
+			return 2
+		}
+		return 0
+	})
+
+	site := &Site{log: util.NewLogger("test")}
+	res, err := site.homeProfileByWeekday(col, 2*96)
+	require.NoError(t, err)
+
+	for i, v := range res {
+		assert.Equal(t, 2000.0, v, "slot %d", i)
+	}
+}
+
+func TestHomeWeekdaySetting(t *testing.T) {
+	site := &Site{log: util.NewLogger("test")}
+	assert.False(t, site.homeWeekday(), "off by default")
+
+	require.NoError(t, site.SetLmAdvanced("homeWeekday", 1))
+	assert.True(t, site.homeWeekday())
+
+	require.Error(t, site.SetLmAdvanced("homeWeekday", 2))
+	require.NoError(t, site.SetLmAdvanced("homeWeekday", 0))
+	assert.False(t, site.homeWeekday())
+}
diff --git a/i18n/de.json b/i18n/de.json
index a9b28c2662..609dcae04a 100644
--- a/i18n/de.json
+++ b/i18n/de.json
@@ -527,7 +527,15 @@
       "gridChargeWindowHelp": "Nur mit Optimizer: So viel Zeit bekommt er beim Batterie-Netzladen nach Ladestand bis zum Stopp-Ladestand und lädt in den günstigsten Stunden davon. 1 h = sofort.",
       "circuitLabel": "Stromkreis Lastmanagement (Peak)",
       "circuitHelp": "Der Stromkreis mit deiner Peak-Grenze, nicht der Absicherung. Nur er erscheint unter Mehr → Lastmanagement (Peak), wird dort mit dem Schalter aufgehoben und steigt bei Follow the Peak mit.",
-      "circuitAll": "Keiner – alle Stromkreise, keiner steigt mit"
+      "circuitAll": "Keiner – alle Stromkreise, keiner steigt mit",
+      "homeWeekdayLabel": "Verbrauchsprognose",
+      "homeWeekdayHelp": "Für den Optimizer. Nach Wochentag: jeder Tag aus demselben Wochentag der letzten 8 Wochen, z. B. Wochenende anders als Werktage. Fehlen noch Daten, gilt der Durchschnitt.",
+      "homeWeekdayOff": "Durchschnitt der letzten 28 Tage",
+      "homeWeekdayOn": "Nach Wochentag",
+      "percentileLabel": "Sicherheitszuschlag Verbrauch",
+      "percentileHelp": "Statt des Mittelwerts je Viertelstunde ein höherer Wert der Vergangenheit, z. B. 80 %: nur 2 von 10 Tagen lagen darüber. Der Optimizer hält dann mehr Batterie zurück. Gilt auch für die Profile der Heizgeräte.",
+      "percentileAverage": "Keiner (Durchschnitt)",
+      "percentileValue": "{percentile} %"
     },
     "lmpriorities": {
       "battery": "Hausbatterie (Netzladen)",
diff --git a/i18n/en.json b/i18n/en.json
index 27b6335a71..913b93601f 100644
--- a/i18n/en.json
+++ b/i18n/en.json
@@ -527,7 +527,15 @@
       "gridChargeWindowHelp": "Optimizer only: the time it gets for soc-based battery grid charging to reach the stop soc, charging in the cheapest hours of it. 1 h = right away.",
       "circuitLabel": "Load management (peak) circuit",
       "circuitHelp": "The circuit holding your peak limit, not the fuse. Only it shows under More → Load management (peak), is lifted by the switch there and rises with follow the peak.",
-      "circuitAll": "None – all circuits, none rises along"
+      "circuitAll": "None – all circuits, none rises along",
+      "homeWeekdayLabel": "Consumption forecast",
+      "homeWeekdayHelp": "For the optimizer. By weekday: each day from the same weekday of the last 8 weeks, e.g. weekends differ from working days. Without enough data yet, the average applies.",
+      "homeWeekdayOff": "Average of the last 28 days",
+      "homeWeekdayOn": "By weekday",
+      "percentileLabel": "Consumption safety margin",
+      "percentileHelp": "Instead of the mean per quarter hour a higher value from the past, e.g. 80 %: only 2 of 10 days were above it. The optimizer then keeps more battery back. Also applies to the heating devices' profiles.",
+      "percentileAverage": "None (average)",
+      "percentileValue": "{percentile} %"
     },
     "lmpriorities": {
       "battery": "Home battery (grid charging)",