You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@streampipes.apache.org by ri...@apache.org on 2026/10/27 20:10:08 UTC

(streampipes-website) 05/08: Improve image style

This is an automated email from the ASF dual-hosted git repository.

dominikriemer pushed a commit to branch website-redesign
in repository https://gitbox.apache.org/repos/asf/streampipes-website.git

commit 0b52dc2c84e64e68c00b49e629de9dfd7d2997bd
Author: Dominik Riemer <do...@gmail.com>
AuthorDate: Tue Oct 27 19:47:00 2026 +0100

    Improve image style
---
 website-v2/src/components/home/Homepage.tsx        | 90 +++++++++++-----------
 website-v2/src/components/ui/index.tsx             |  6 +-
 website-v2/src/components/ui/ui.module.css         |  7 +-
 website-v2/src/components/usecases/UseCasePage.tsx |  4 +-
 website-v2/src/components/usecases/data.ts         | 30 ++++----
 website-v2/src/pages/architecture.tsx              | 40 +++++-----
 website-v2/src/pages/community/get-involved.tsx    | 18 ++---
 website-v2/src/pages/community/mailing-lists.tsx   |  6 +-
 website-v2/src/pages/community/team.tsx            |  4 +-
 website-v2/src/pages/download.tsx                  | 16 ++--
 website-v2/src/pages/enterprise.tsx                | 34 ++++----
 website-v2/src/pages/features.tsx                  | 38 ++++-----
 website-v2/src/pages/integrations.tsx              |  4 +-
 website-v2/src/pages/use-cases/index.tsx           |  2 +-
 14 files changed, 151 insertions(+), 148 deletions(-)

diff --git a/website-v2/src/components/home/Homepage.tsx b/website-v2/src/components/home/Homepage.tsx
index 9b3f396d1..a14ec440c 100644
--- a/website-v2/src/components/home/Homepage.tsx
+++ b/website-v2/src/components/home/Homepage.tsx
@@ -77,26 +77,26 @@ const icons = {
 };
 
 const developerTools = [
-  {label: 'Python client', title: 'Your data, in notebooks and apps.', text: 'Bring historical datasets into pandas, work with live streams and automate the platform from Python.', language: 'python', file: 'explore_dataset.py',
+  {label: 'Python client', title: 'Your data in a notebook.', text: 'Load a dataset into pandas, subscribe to a live stream, or script the platform from Python.', language: 'python', file: 'explore_dataset.py',
     code: '# With an authenticated StreamPipes client\n# and an existing dataset named "flow-rate":\n\ndataset = client.dataLakeMeasureApi.get(\n    identifier="flow-rate"\n)\n\nframe = dataset.to_pandas()\nprint(frame.describe())',
     links: [{label: 'Python client docs', to: pythonDocs}]},
-  {label: 'Java client & APIs', title: 'Automate from your own services.', text: 'Inspect resources, subscribe to streams and manage pipeline lifecycles through the Java client or the REST API.', language: 'java', file: 'PipelineAutomation.java',
+  {label: 'Java client & APIs', title: 'Automate it from your own services.', text: 'List resources, subscribe to streams, and start or stop pipelines through the Java client or the REST API.', language: 'java', file: 'PipelineAutomation.java',
     code: 'var client = StreamPipesClient.create(\n    "localhost", 80,\n    StreamPipesCredentials.withApiKey(user, apiKey));\n\nclient.pipelines().all()\n    .forEach(p -> client.pipelines().start(p));',
     links: [{label: 'Java client & APIs', to: docs('use-programmatic-access')}]},
-  {label: 'Functions', title: 'Write the logic your application needs.', text: 'Subscribe to connected streams and handle events in code, without building a reusable element for the visual editor.', language: 'java', file: 'StreamPipesFunction.java',
+  {label: 'Functions', title: 'Logic that does not fit a pipeline element.', text: 'A Function subscribes to a stream and handles each event in code. No need to build a reusable element for the editor when you need the logic only once.', language: 'java', file: 'StreamPipesFunction.java',
     code: '@Override\npublic List<String> requiredStreamIds() {\n  return List.of("your-stream-id");\n}\n\n@Override\npublic void onEvent(Event event, String streamId) {\n  // Apply your application-specific logic here.\n}',
     links: [{label: 'Build a Function', to: docs('extend-sdk-functions')}]},
-  {label: 'Extension SDK', title: 'Make the platform fit your domain.', text: 'Build reusable adapters, processors and sinks. Describe their inputs and configuration so your team can use them inside StreamPipes.', language: 'java', file: 'ExtensionService.java',
+  {label: 'Extension SDK', title: 'Extensions for your own systems.', text: 'Write adapters, processors and sinks for the protocols and logic your plant needs. Describe their configuration, and your team uses them in the editor like any built-in element.', language: 'java', file: 'ExtensionService.java',
     code: '@Override\npublic SpServiceDefinition provideServiceDefinition() {\n  return SpServiceDefinitionBuilder.create(\n      "plant-extensions", "Plant extensions", "", 8090)\n    .registerPipelineElement(new MyProcessor())\n    .build();\n}',
     links: [{label: 'Start with the SDK', to: docs('extend-setup')}, {label: 'Extend the UI', to: docs('extend-customize-ui')}]},
 ];
 
 const modules = [
-  {label: 'Connect', src: '/img/home/connect-create-select-adapter.webp', alt: 'Adapter library with industrial and software connectors', caption: 'Connect: choose an adapter for OPC UA, S7, Modbus, MQTT, Kafka and more.', to: docs('use-connect')},
+  {label: 'Connect', src: '/img/home/connect-create-select-adapter.webp', alt: 'Adapter library with industrial and software connectors', caption: 'Connect: pick an adapter for OPC UA, S7, Modbus, MQTT, Kafka and others.', to: docs('use-connect')},
   {label: 'Pipelines', src: '/img/home/pipeline-editor-example.webp', alt: 'Visual pipeline editor routing machine data to trend detection, a Teams notification and storage', caption: 'Pipelines: filter, detect and route live data in the visual editor.', to: docs('use-pipelines')},
-  {label: 'Datasets', src: '/img/home/dataset-overview.webp', alt: 'Dataset workspace with stored events, retention and export providers', caption: 'Datasets: persisted history with retention, export and permissions.', to: docs('use-datasets')},
+  {label: 'Datasets', src: '/img/home/dataset-overview.webp', alt: 'Dataset workspace with stored events, retention and export providers', caption: 'Datasets: stored history with retention rules, export and permissions.', to: docs('use-datasets')},
   {label: 'Charts', src: '/img/home/chart-timeseries.webp', alt: 'Chart editor with a time-series visualization', caption: 'Charts: query a dataset and pick the right visualization.', to: docs('use-charts')},
-  {label: 'Dashboards', src: '/img/home/dashboard-create.webp', alt: 'Dashboard with a gauge, a flow-rate chart and a machine status indicator', caption: 'Dashboards: compose saved charts into one operational view.', to: docs('use-dashboards')},
+  {label: 'Dashboards', src: '/img/home/dashboard-create.webp', alt: 'Dashboard with a gauge, a flow-rate chart and a machine status indicator', caption: 'Dashboards: saved charts combined into one view for the team.', to: docs('use-dashboards')},
   {label: 'Assets', src: '/img/home/asset-asset-link-overview.webp', alt: 'Machine asset with site assignment and linked resources', caption: 'Assets: plants, lines and machines with their linked data.', to: docs('use-assets')},
 ];
 
@@ -118,12 +118,12 @@ function Hero({stars}: {stars: number | null}) {
     <Container center narrow className={styles.heroCopy}>
       <Badge to="/download/">Apache top-level project ยท Release {RELEASE.version}</Badge>
       <Headline level={1}>The open-source platform<br />for <Accent>industrial data</Accent>.</Headline>
-      <Lead>Connect machines, process live streams, store datasets and build the dashboards your team runs on. On your infrastructure, under the Apache license.</Lead>
+      <Lead>StreamPipes connects to machines and industrial systems, works on the data as it arrives, keeps the history, and turns it into charts and dashboards. It runs on your own servers under the Apache license.</Lead>
       <Actions className={styles.heroActions}>
         <Button to={quickstart} size="large">Get started</Button>
         <Button href={githubRepo} variant="secondary" size="large" arrow={false}>{icons.github}{stars === null ? 'Star on GitHub' : `${stars.toLocaleString('en-US')} stars on GitHub`}</Button>
       </Actions>
-      <p className={styles.heroNote}>Docker Compose or Kubernetes. No account, no vendor lock-in.</p>
+      <p className={styles.heroNote}>Runs with Docker Compose or Kubernetes. Nothing to sign up for.</p>
     </Container>
     <Container className={styles.heroFrame}>
       <ModuleShowcase />
@@ -135,7 +135,7 @@ function Connectors() {
   return <Section tone="light" bordered className={styles.connectors} aria-label="Supported systems">
     <Container>
       <div className={styles.connectorsHead}>
-        <div><Eyebrow>Connectivity</Eyebrow><Headline level={3}>Works with the systems you already run.</Headline></div>
+        <div><Eyebrow>Connectivity</Eyebrow><Headline level={3}>Works with the systems you already have.</Headline></div>
         <Button to="/integrations/" variant="ghost">All {ext.Adapters + ext['Data Processors'] + ext['Data Sinks']} integrations</Button>
       </div>
       <LogoWall logos={connectors} label="Supported protocols, brokers and databases" />
@@ -147,20 +147,20 @@ function Platform({stars}: {stars: number | null}) {
   return <Section id="platform" tone="light" bordered>
     <Container>
       <Stats>
-        <Stat value="Apache" label="Top-level project" note="Governed by the Apache Software Foundation" to="https://www.apache.org/" />
+        <Stat value="Apache" label="Top-level project" note="A project of the Apache Software Foundation" to="https://www.apache.org/" />
         <Stat value={stars === null ? 'Open source' : stars.toLocaleString('en-US')} label={stars === null ? 'Apache License 2.0' : 'GitHub stars'} note={stars === null ? 'Source on GitHub' : 'Apache License 2.0'} to={githubRepo} />
         <Stat value={`${ext.Adapters}+`} label="Adapters" note="OPC UA, S7, Modbus, MQTT, Kafka and more" to={docs('use-connect')} />
-        <Stat value={`${ext['Data Processors'] + ext['Data Sinks']}+`} label="Processors and sinks" note="Filter, enrich, detect, route and store" to={docs('use-pipelines')} />
+        <Stat value={`${ext['Data Processors'] + ext['Data Sinks']}+`} label="Processors and sinks" note="Filtering, enrichment, detection, routing, storage" to={docs('use-pipelines')} />
       </Stats>
       <div className={styles.platformHead}>
-        <SectionHead eyebrow="Platform" title={<>One platform.<br />The whole data journey.</>} lead="From the first machine connection to the dashboard on the shop floor. Every step is built in, and every step is open." action={<Button to="/features/" variant="ghost">All features</Button>} />
+        <SectionHead eyebrow="Platform" title={<>From the first connection<br />to the dashboard.</>} lead="Connecting a machine, processing its data, storing it and charting it usually means four tools. In StreamPipes they are modules of one platform, and all of them are open source." action={<Button to="/features/" variant="ghost">All features</Button>} />
       </div>
       <Bento>
-        <Card span={3} to={docs('use-connect')} media={{src: '/img/home/connect-create-select-adapter.webp', alt: 'StreamPipes adapter library'}} title="Connect" link="Explore connectivity">Bring machines, brokers and software systems into the platform with guided adapters, event previews and schema refinement.</Card>
-        <Card span={3} to={docs('use-pipelines')} media={{src: '/img/home/pipeline-editor-example.webp', alt: 'StreamPipes visual pipeline editor'}} title="Pipelines" link="Explore pipelines">Filter, enrich, detect and route live data in a visual editor. Reuse validated pipelines as code.</Card>
-        <Card span={2} to={docs('use-dashboards')} media={{src: '/img/home/chart-timeseries.webp', alt: 'StreamPipes chart editor'}} title="Charts and dashboards" link="Explore dashboards">Query datasets, choose the right visualization and compose shared operational views.</Card>
-        <Card span={2} to={docs('use-datasets')} icon={icons.db} title="Datasets" link="Explore datasets">Persist streams as historical data. Inspect, export, import CSV and define retention and archival.</Card>
-        <Card span={2} to={docs('use-assets')} icon={icons.site} title="Assets and sites" link="Explore assets">Model plants, lines and machines and link every stream, dataset, pipeline and dashboard to them.</Card>
+        <Card span={3} to={docs('use-connect')} media={{src: '/img/home/connect-create-select-adapter.webp', alt: 'StreamPipes adapter library'}} title="Connect" link="Explore connectivity">Adapters connect machines, brokers and other software. You see the incoming events before you save anything, and you fix field names, types and units once.</Card>
+        <Card span={3} to={docs('use-pipelines')} media={{src: '/img/home/pipeline-editor-example.webp', alt: 'StreamPipes visual pipeline editor'}} title="Pipelines" link="Explore pipelines">Filter, enrich and route live data in a visual editor. Elements are checked against the stream's schema, so a pipeline that saves is a pipeline that runs.</Card>
+        <Card span={2} to={docs('use-dashboards')} media={{src: '/img/home/chart-timeseries.webp', alt: 'StreamPipes chart editor'}} title="Charts and dashboards" link="Explore dashboards">Query a dataset, pick a chart type, and put several charts together into a dashboard for the team.</Card>
+        <Card span={2} to={docs('use-datasets')} icon={icons.db} title="Datasets" link="Explore datasets">Stored history for the streams you choose to keep. Inspect it, export it, import CSV files, and set retention rules.</Card>
+        <Card span={2} to={docs('use-assets')} icon={icons.site} title="Assets and sites" link="Explore assets">Describe your plants, lines and machines, and attach the streams, datasets, pipelines and dashboards that belong to each.</Card>
       </Bento>
     </Container>
   </Section>;
@@ -169,7 +169,7 @@ function Platform({stars}: {stars: number | null}) {
 function UseCases() {
   return <Section id="use-cases" tone="light" bordered>
     <Container>
-      <SectionHead eyebrow="Use cases" title={<>Built for the work<br />on the shop floor.</>} lead="Typical scenarios, each with the adapters, processors and sinks involved and the guide to follow." action={<Button to="/use-cases/" variant="ghost">All use cases</Button>} />
+      <SectionHead eyebrow="Use cases" title={<>What people<br />build with it.</>} lead="Five scenarios we see often, with the adapters, processors and sinks they use and the guide that goes with each." action={<Button to="/use-cases/" variant="ghost">All use cases</Button>} />
       <Bento>
         {useCases.slice(0, 3).map(u => <Card key={u.slug} span={2} to={`/use-cases/${u.slug}/`} media={{src: u.cover.src, alt: u.cover.alt}} title={u.title} link="Read the use case">{u.lead}</Card>)}
       </Bento>
@@ -180,7 +180,7 @@ function UseCases() {
 function HowItWorks() {
   return <Section id="architecture" tone="tint" bordered>
     <Container>
-      <SectionHead eyebrow="How it works" title={<>From machine signal<br />to insight.</>} lead="Adapters turn raw signals into typed streams. Pipelines act on them in real time. Datasets keep the history. Charts and dashboards make it visible." />
+      <SectionHead eyebrow="How it works" title={<>What happens<br />to an event.</>} lead="An adapter turns raw signals into a typed stream. Pipelines work on that stream as events arrive. Datasets keep what you want to look at later, and charts and dashboards show it." />
       <div className={styles.flow}>
         <FlowDiagram nodes={[
           {label: 'Machines and systems', sub: 'OPC UA, S7, MQTT, Kafka'},
@@ -196,15 +196,15 @@ function HowItWorks() {
 
 function Architecture() {
   const layers = [
-    {title: 'Interfaces', text: 'The web UI for everyday work, Java and Python clients and REST APIs for automation, and connections to third-party systems.'},
-    {title: 'Core', text: 'Manages adapters, pipelines, datasets, assets and users, monitors every running component and serves the UI.'},
-    {title: 'Messaging layer', text: 'NATS or Kafka carries events between adapters, pipelines and sinks, so each part can run where it fits best.'},
-    {title: 'Extension services', text: 'Adapters, processors, sinks and Functions run as separate services. Add your own with the SDK and install them at runtime.'},
-    {title: 'Time-series storage', text: 'Persisted datasets live in a time-series database with retention rules and export to CSV, JSON or Excel.'},
+    {title: 'Interfaces', text: 'The web UI for daily work, plus Java and Python clients and a REST API for anything you want to automate.'},
+    {title: 'Core', text: 'Keeps track of adapters, pipelines, datasets, assets and users, watches what is running, and serves the UI.'},
+    {title: 'Messaging layer', text: 'NATS or Kafka moves events between adapters, pipelines and sinks. Nothing talks point to point, so each part can run where it makes sense.'},
+    {title: 'Extension services', text: 'Adapters, processors, sinks and Functions are packaged as separate services. Write your own with the SDK and install them while the platform is running.'},
+    {title: 'Time-series storage', text: 'Datasets go into a time-series database. Retention rules decide how long they stay, and you can export them as CSV, JSON or Excel.'},
   ];
   return <Section id="architecture-overview" tone="light" bordered>
     <Container>
-      <SectionHead eyebrow="Architecture" title={<>Built as services.<br />Deployed where you need them.</>} lead="A core, a message broker and any number of extension services. Run everything on one host with Docker Compose, or spread extension services across plants and scale the core on Kubernetes." />
+      <SectionHead eyebrow="Architecture" title={<>Several services,<br />one platform.</>} lead="A core, a message broker, and as many extension services as you need. Run all of it on one host with Docker Compose, or put the extension services into the plants and the core into the data center." />
       <div className={styles.archGrid}>
         <ScreenshotFrame src="/img/home/architecture.webp" alt="StreamPipes architecture: interfaces on top, the core and time-series database in the middle, a messaging layer, and extension services with adapters, processors, sinks and Functions connected to machines" width={1600} height={695} caption="Architecture overview" />
         <ol className={styles.layers}>{layers.map((layer, i) => <li key={layer.title}><span>{String(i + 1).padStart(2, '0')}</span><div><h3>{layer.title}</h3><p>{layer.text}</p></div></li>)}</ol>
@@ -217,13 +217,13 @@ function Architecture() {
 function Deployment() {
   return <Section id="deployment" tone="tint" bordered>
     <Container>
-      <SectionHead eyebrow="Deployment" title={<>Extension services at the edge.<br />One core to manage them.</>} lead="Each plant runs a small extension service next to its PLCs and machines. It connects outbound to the broker, so the OT network needs no inbound ports. Core, storage, processors and sinks stay in IT, managed from one place." />
+      <SectionHead eyebrow="Deployment" title={<>Extension services in the plant,<br />the core where your servers are.</>} lead="Each plant runs a small extension service next to its PLCs and machines. The service connects outbound to the broker, so you do not open any ports into the OT network. The core, the storage and the heavier processing stay in IT." />
       <div className={styles.deployFrame}><DeploymentDiagram /></div>
       <div className={styles.deploySteps}>
         <Steps items={[
-          {title: 'Run it where the data is', text: 'Place extension services in the OT network next to your equipment and keep the core in the data center or cloud. The broker connects both, with control flow only from IT to OT.'},
-          {title: 'Start small, grow in place', text: 'A single Docker Compose host is enough to evaluate. The same services scale out on Kubernetes without changing your pipelines.'},
-          {title: 'Keep the data yours', text: 'Everything runs on your infrastructure. No usage metering, no proprietary formats: export datasets whenever you need.'},
+          {title: 'Run it where the data is', text: 'Put extension services into the plant network, next to the equipment, and keep the core in the data center or in the cloud. The broker connects the two.'},
+          {title: 'Start small, grow in place', text: 'One Docker Compose host is enough to try things out. The same services scale out on Kubernetes later, and your pipelines stay as they are.'},
+          {title: 'The data stays yours', text: 'Everything runs on infrastructure you control. There is no usage metering and no proprietary format, and you can export a dataset whenever you want to.'},
         ]} />
       </div>
       <div className={styles.sectionFoot}><Button to={docs('configure-operate-deployment')} variant="ghost">Deployment options</Button><Button to={docs('configure-operate-extension-services')} variant="ghost">Extension services</Button></div>
@@ -234,16 +234,16 @@ function Deployment() {
 function Enterprise() {
   return <Section id="enterprise" tone="light" bordered>
     <Container>
-      <SectionHead eyebrow="Enterprise readiness" title={<>Ready for the plant.<br />Ready for IT.</>} lead="The controls an IT department expects, built into the open-source platform: identity, access control, audit trail, data lifecycle and secured connections." action={<Button to="/enterprise/" variant="ghost">Everything on enterprise readiness</Button>} />
+      <SectionHead eyebrow="Enterprise readiness" title={<>The things<br />IT will ask about.</>} lead="Single sign-on, roles and permissions, an audit log, retention rules and encrypted connections are part of the platform. There is no separate enterprise edition." action={<Button to="/enterprise/" variant="ghost">Everything on enterprise readiness</Button>} />
       <Bento>
-        <Card span={2} to={docs('configure-operate-environment-variables')} icon={icons.lock} title="Single sign-on" link="Configure OpenID Connect">Log in through your identity provider with OpenID Connect or OAuth2. Configure one or more providers and map roles from token claims.</Card>
-        <Card span={2} to={docs('configure-operate-security')} icon={icons.users} title="Roles, groups and permissions" link="User management">Built-in and custom roles from fine-grained privileges, user groups, per-resource permissions with owners and public links, service accounts and API keys.</Card>
-        <Card span={2} to={docs('configure-operate-general-settings')} icon={icons.list} title="Audit log" link="Audit log">Who changed what: logins, adapters, datasets, charts, dashboards, exports and security groups. Filter, download as CSV, JSON or Excel, and apply retention rules.</Card>
-        <Card span={2} to={docs('use-datasets')} icon={icons.clock} title="Data retention and archival" link="Dataset retention">Per-dataset retention policies that delete, archive or both, on a daily, weekly or monthly schedule. Archive to a local folder or S3 and export CSV, JSON or Excel.</Card>
-        <Card span={2} to={docs('configure-operate-extension-services')} icon={icons.shield} title="Secured connections" link="Certificates and transport">HTTPS for the UI, encrypted secrets at rest, certificate management for OPC UA, MQTT and Kafka with expiry alerts, and NATS transport between core and extension services.</Card>
-        <Card span={2} to={docs('configure-operate-deployment')} icon={icons.activity} title="Operations" link="Deploy and operate">Metrics and logs per adapter and pipeline, a Prometheus endpoint, a Helm chart with Prometheus and Grafana, export and import of resources, and automatic migrations on upgrade.</Card>
+        <Card span={2} to={docs('configure-operate-environment-variables')} icon={icons.lock} title="Single sign-on" link="Configure OpenID Connect">Sign in through your identity provider with OpenID Connect or OAuth2. Several providers can be configured side by side, and roles can be taken from token claims.</Card>
+        <Card span={2} to={docs('configure-operate-security')} icon={icons.users} title="Roles, groups and permissions" link="User management">Built-in roles, custom roles made from individual privileges, user groups, and permissions on every resource. Service accounts and API keys for anything automated.</Card>
+        <Card span={2} to={docs('configure-operate-general-settings')} icon={icons.list} title="Audit log" link="Audit log">Logins and changes to adapters, datasets, charts, dashboards, exports and security settings are recorded. Filter the log, download it, and give it its own retention rule.</Card>
+        <Card span={2} to={docs('use-datasets')} icon={icons.clock} title="Data retention and archival" link="Dataset retention">Each dataset gets a retention policy that deletes old data, archives it to a folder or S3, or does both, on a daily, weekly or monthly schedule.</Card>
+        <Card span={2} to={docs('configure-operate-extension-services')} icon={icons.shield} title="Secured connections" link="Certificates and transport">HTTPS for the UI, encrypted secrets at rest, and certificate management for OPC UA, MQTT and Kafka with a warning before a certificate expires.</Card>
+        <Card span={2} to={docs('configure-operate-deployment')} icon={icons.activity} title="Operations" link="Deploy and operate">Metrics and logs for every adapter and pipeline, a Prometheus endpoint, a Helm chart that includes Prometheus and Grafana, and migrations that run on upgrade.</Card>
       </Bento>
-      <p className={styles.enterpriseNote}>Terms-of-use acknowledgment after login, self-registration and password-recovery toggles, and a configurable app name round it off. All of it is Apache licensed; nothing sits behind an enterprise tier.</p>
+      <p className={styles.enterpriseNote}>Also in the box: a terms-of-use screen after login, switches for self-registration and password recovery, and a configurable app name. All of it under the Apache license.</p>
     </Container>
   </Section>;
 }
@@ -253,7 +253,7 @@ function Developers() {
   const tool = developerTools[selected];
   return <Section id="developers" tone="light" bordered>
     <Container>
-      <SectionHead eyebrow="Developers" title={<>Integrate. Automate.<br />Extend.</>} lead="Start with the visual tools. Go further with client libraries, event-driven Functions and an SDK for your own extensions." />
+      <SectionHead eyebrow="Developers" title={<>Use it from<br />code, too.</>} lead="The visual tools are the start. Python and Java clients, Functions for event-driven code and an SDK for your own extensions cover the rest." />
       <Tabs id="developer" label="Developer tools" items={developerTools.map(t => t.label)} selected={selected} onSelect={setSelected} />
       <TabPanel id="developer" selected={selected} className={styles.developerPanel}>
         <div className={styles.developerCopy}>
@@ -273,18 +273,18 @@ function GetStarted() {
       <div className={styles.ctaGrid}>
         <div>
           <Eyebrow>Get started</Eyebrow>
-          <Headline level={2}>Running in minutes.<br />On your machine.</Headline>
-          <Lead>One command downloads the Compose files for release {RELEASE.version} and starts StreamPipes with Docker. Then follow the quickstart from your first data source to a working dashboard.</Lead>
+          <Headline level={2}>Up and running<br />in a few minutes.</Headline>
+          <Lead>The command on the right downloads the Compose files for release {RELEASE.version} and starts StreamPipes with Docker. From there, the quickstart takes you from a first data source to a dashboard.</Lead>
           <Actions className={styles.ctaActions}><Button to={quickstart} size="large">Open the quickstart</Button><Button to="/download/" variant="secondary" size="large">All downloads</Button></Actions>
         </div>
         <CodePanel title="docker compose" language="bash" code={installCommand} wrap meta={`release ${RELEASE.version}`} />
       </div>
       <div className={styles.community}>
         <FeatureList items={[
-          {icon: icons.github, title: 'GitHub Discussions', text: 'Questions, ideas and show-and-tell with maintainers and users.', to: 'https://github.com/apache/streampipes/discussions'},
-          {icon: icons.mail, title: 'Mailing lists', text: 'Development and user lists, the Apache way. Decisions happen in the open.', to: '/community/mailing-lists/'},
-          {icon: icons.help, title: 'Support and training', text: 'Community support on GitHub, commercial support from companies around the project.', to: docs('community-get-help')},
-          {icon: icons.code, title: 'Contribute', text: 'Code, documentation, testing and ideas. Start with a discussion or pick an issue.', to: '/community/get-involved/'},
+          {icon: icons.github, title: 'GitHub Discussions', text: 'Questions, ideas, and showing what you built. The maintainers read it.', to: 'https://github.com/apache/streampipes/discussions'},
+          {icon: icons.mail, title: 'Mailing lists', text: 'The user list for questions, the dev list for decisions. This is how Apache projects work.', to: '/community/mailing-lists/'},
+          {icon: icons.help, title: 'Support and training', text: 'The community helps on GitHub. If you need guaranteed response times, companies around the project offer support contracts.', to: docs('community-get-help')},
+          {icon: icons.code, title: 'Contribute', text: 'Code, docs, tests, ideas. Start with a discussion or pick an issue labelled good first issue.', to: '/community/get-involved/'},
         ]} />
       </div>
     </Container>
diff --git a/website-v2/src/components/ui/index.tsx b/website-v2/src/components/ui/index.tsx
index 92756ec1c..b3cb98bbd 100644
--- a/website-v2/src/components/ui/index.tsx
+++ b/website-v2/src/components/ui/index.tsx
@@ -159,8 +159,10 @@ export function CodePanel({title, language, code, wrap = false, meta}: {title: s
 /* ---------- Screenshot frame ---------- */
 
 export function ScreenshotFrame({src, alt, caption, width, height, priority = false, className}: {src: string; alt: string; caption?: React.ReactNode; width?: number; height?: number; priority?: boolean; className?: string}) {
-  return <figure className={clsx(s.frame, className)} style={{margin: 0}}>
-    <img src={src} alt={alt} width={width} height={height} loading={priority ? 'eager' : 'lazy'} decoding="async" {...(priority ? {fetchPriority: 'high'} : {})} />
+  return <figure className={s.figure}>
+    <div className={clsx(s.frame, className)}>
+      <img src={src} alt={alt} width={width} height={height} loading={priority ? 'eager' : 'lazy'} decoding="async" {...(priority ? {fetchPriority: 'high'} : {})} />
+    </div>
     {caption && <figcaption className={s.frameCaption}>{caption}</figcaption>}
   </figure>;
 }
diff --git a/website-v2/src/components/ui/ui.module.css b/website-v2/src/components/ui/ui.module.css
index 7c53eb005..fbfa69f50 100644
--- a/website-v2/src/components/ui/ui.module.css
+++ b/website-v2/src/components/ui/ui.module.css
@@ -123,9 +123,10 @@ a.stat:hover .statValue { color: var(--sp-green-dark); }
 .wrap :global(pre), .wrap :global(code), .wrap :global(.token-line) { white-space: pre-wrap !important; word-break: break-all; float: none !important; min-width: 0 !important; }
 
 /* ---------- Screenshot frame ---------- */
-.frame { border-radius: 10px; overflow: hidden; border: 1px solid var(--sp-line); background: var(--sp-surface); box-shadow: 0 24px 60px -36px rgba(27, 20, 100, .35); }
-.frame img { width: 100%; }
-.frameCaption { padding: 10px 14px; border-top: 1px solid var(--sp-line); font-size: 12px; color: var(--sp-muted); background: var(--sp-surface-2); }
+.figure { margin: 0; }
+.frame { border-radius: 8px; overflow: hidden; border: 1px solid var(--sp-line); background: var(--sp-surface); }
+.frame img { width: 100%; display: block; }
+.frameCaption { margin-top: 10px; font-size: 13px; line-height: 1.5; color: var(--sp-muted); }
 
 /* ---------- Flow diagram ---------- */
 .flow { width: 100%; height: auto; display: block; font-family: var(--sp-font); }
diff --git a/website-v2/src/components/usecases/UseCasePage.tsx b/website-v2/src/components/usecases/UseCasePage.tsx
index 5fc3c4c53..ec6576a0d 100644
--- a/website-v2/src/components/usecases/UseCasePage.tsx
+++ b/website-v2/src/components/usecases/UseCasePage.tsx
@@ -49,7 +49,7 @@ export default function UseCasePage({useCase: u}: {useCase: UseCase}) {
         <div className={styles.twoCol}>
           <div>
             <Headline level={2}>Extensions used</Headline>
-            <Lead>All included in the standard installation.</Lead>
+            <Lead>All of these come with the standard installation.</Lead>
             <ul className={styles.chips}>{u.extensions.map(e => <li key={e.id}><Link to={`/docs/pe/org.apache.streampipes.${e.id}/`}>{e.name}</Link></li>)}</ul>
             <Button to="/integrations/" variant="ghost">Browse all integrations</Button>
           </div>
@@ -63,7 +63,7 @@ export default function UseCasePage({useCase: u}: {useCase: UseCase}) {
     <Section tone="light" bordered>
       <Container>
         <div className={styles.twoCol}>
-          <div><Headline level={2}>Try it on your machine.</Headline><Lead>One command starts StreamPipes with Docker. The quickstart then takes you from the first data source to a dashboard.</Lead><div className={styles.actions}><Button to="/docs/quick-start-guide/">Open the quickstart</Button><Button to="/download/" variant="secondary">All downloads</Button></div></div>
+          <div><Headline level={2}>Try it on your machine.</Headline><Lead>One command starts StreamPipes with Docker. The quickstart takes you from there to a first dashboard.</Lead><div className={styles.actions}><Button to="/docs/quick-start-guide/">Open the quickstart</Button><Button to="/download/" variant="secondary">All downloads</Button></div></div>
           <CodePanel title="docker compose" language="bash" code={installCommand} wrap meta={`release ${RELEASE}`} />
         </div>
       </Container>
diff --git a/website-v2/src/components/usecases/data.ts b/website-v2/src/components/usecases/data.ts
index 1884e146f..83f0a36c2 100644
--- a/website-v2/src/components/usecases/data.ts
+++ b/website-v2/src/components/usecases/data.ts
@@ -7,12 +7,12 @@ export const useCases: UseCase[] = [
     slug: 'condition-monitoring',
     eyebrow: 'Operations',
     title: 'Condition monitoring with OPC UA',
-    lead: 'Connect machines over OPC UA, watch the values that matter on a dashboard, and get a message when a trend or threshold needs attention.',
+    lead: 'Connect machines over OPC UA, keep an eye on the values that matter, and get a message when a trend or a threshold needs attention.',
     summary: 'Condition monitoring with Apache StreamPipes: connect machines via OPC UA, detect trends and threshold violations in real time, notify the team and monitor on dashboards.',
     cover: {src: img('pipeline-editor-example'), alt: 'Pipeline routing CNC process data to trend detection, a Microsoft Teams notification and dataset storage'},
     problem: [
-      'Most modern machines expose their state over OPC UA, but the values stay locked in the controller or in a vendor tool. Operators want one view across machines, and engineers want to know about drifts before they become stops.',
-      'Doing this with custom scripts means maintaining connection code, buffering, storage and a dashboard per machine. StreamPipes covers all of that out of the box and keeps the data in your own infrastructure.',
+      'Most newer machines expose their state over OPC UA, but the values tend to stay in the controller or in the vendor\'s own tool. Operators want one view across machines. Engineers want to hear about a drift before it turns into a stop.',
+      'You can script all of this, but then you maintain connection code, buffering, storage and a dashboard for every machine. StreamPipes has those parts built in, and the data stays on your own infrastructure.',
     ],
     steps: [
       {title: 'Connect the machine', text: 'Create an OPC UA adapter, browse the server\'s node tree, pick the variables and choose pull or subscription mode. Signed and encrypted connections are supported.'},
@@ -39,12 +39,12 @@ export const useCases: UseCase[] = [
     slug: 'plc-data-to-kafka-and-influxdb',
     eyebrow: 'Integration',
     title: 'PLC data to Kafka and InfluxDB',
-    lead: 'Read Siemens S7 and Modbus controllers, harmonize units and field names, and forward clean events to the systems your IT already runs.',
+    lead: 'Read Siemens S7 and Modbus controllers, clean up units and field names, and forward the events to the systems IT already runs.',
     summary: 'Forward Siemens S7 and Modbus PLC data to Apache Kafka and InfluxDB with Apache StreamPipes: connect with PLC4X adapters, harmonize fields and units, and publish to brokers and databases.',
     cover: {src: img('connect-create-select-adapter'), alt: 'Adapter library with PLC4X, Kafka and other connectors'},
     problem: [
-      'IT teams want machine data in Kafka topics and time-series databases, in a schema they can rely on. OT teams want nothing installed on the controllers and no inbound connections into the plant network.',
-      'StreamPipes reads the controllers with its PLC4X adapters, lets you fix names, units and types once in the adapter, and publishes the result to Kafka, InfluxDB or both. The extension service doing the reading can run next to the machines.',
+      'IT wants machine data in Kafka topics and a time-series database, in a schema they can rely on. OT wants nothing installed on the controllers and no connections opened into the plant network.',
+      'StreamPipes reads the controllers with its PLC4X adapters, lets you fix names, units and types once in the adapter, and publishes the result to Kafka, InfluxDB or both. The extension service that does the reading can sit next to the machines.',
     ],
     steps: [
       {title: 'Connect the controller', text: 'Create a PLC4X S7 or Modbus TCP adapter, define the addresses to read and the polling interval, and preview incoming events before you start.'},
@@ -71,12 +71,12 @@ export const useCases: UseCase[] = [
     slug: 'mqtt-unified-namespace',
     eyebrow: 'Architecture',
     title: 'MQTT and a unified namespace',
-    lead: 'Subscribe to the topics your broker already carries, turn raw payloads into typed streams with context, and publish enriched results back into the namespace.',
+    lead: 'Subscribe to the topics your broker already carries, turn raw payloads into typed streams with context, and publish the results back into the namespace.',
     summary: 'Use Apache StreamPipes with MQTT and a unified namespace: subscribe to broker topics, add types, units and asset context, process in pipelines, and publish results back to MQTT.',
     cover: {src: img('connect-create-adapter-settings-preview'), alt: 'Adapter settings with a live event preview'},
     problem: [
-      'A unified namespace puts every signal on an MQTT broker, but a topic is just bytes. Teams still need types, units, asset context and somewhere to compute and store derived values.',
-      'StreamPipes subscribes to the broker with TLS and authentication, maps payloads to typed streams, attaches assets and sites, and writes results back as new topics, so the namespace gets richer instead of being duplicated elsewhere.',
+      'A unified namespace puts every signal on an MQTT broker. A topic, though, is just bytes. Someone still has to add types, units and context, and there has to be a place to compute and store derived values.',
+      'StreamPipes subscribes to the broker with TLS and authentication, maps the payloads to typed streams, attaches assets and sites, and writes results back as new topics. The namespace gets richer instead of being copied somewhere else.',
     ],
     steps: [
       {title: 'Subscribe', text: 'Create an MQTT adapter with the broker URL, credentials or certificates, and the topic. The event preview shows the parsed payload before you commit.'},
@@ -103,12 +103,12 @@ export const useCases: UseCase[] = [
     slug: 'anomaly-detection-with-python',
     eyebrow: 'Analytics',
     title: 'Anomaly detection with Python Functions',
-    lead: 'Train a model on historical datasets in a notebook, then run it on live streams as a StreamPipes Function and write predictions back as a new stream.',
+    lead: 'Train a model on a dataset in a notebook, run it on the live stream as a StreamPipes Function, and get the predictions back as a stream.',
     summary: 'Anomaly detection with Apache StreamPipes and Python: load datasets into pandas, train a model, run it on live data as a StreamPipes Function and visualize predictions in charts.',
     cover: {src: img('prediction-analysis'), alt: 'Chart comparing sensor values with model predictions'},
     problem: [
-      'Data scientists work in Python and notebooks. Operators work in dashboards. The gap between a trained model and a running one is usually glue code, a deployment and a second data path.',
-      'With the StreamPipes Python client, historical datasets load straight into pandas. The same client runs a Function that subscribes to the live stream, scores each event, and publishes the result as a new stream that charts and pipelines can use.',
+      'Data scientists work in Python. Operators look at dashboards. Between a trained model and a running one there is usually glue code, a deployment, and a second data path that nobody wants to own.',
+      'With the Python client, a dataset loads straight into pandas. The same client runs a Function that subscribes to the live stream, scores each event and publishes the result as a new stream, which charts and pipelines can use like any other.',
     ],
     steps: [
       {title: 'Get the history', text: 'Use the Python client to load a dataset into a pandas DataFrame, explore it and train a model, for example with scikit-learn or an ONNX export.'},
@@ -133,12 +133,12 @@ export const useCases: UseCase[] = [
     slug: 'alarms-and-events',
     eyebrow: 'Operations',
     title: 'Alarms, events and notifications',
-    lead: 'Receive OPC UA alarms and events, measure how long states last, and send the right message to the right channel when something changes.',
+    lead: 'Receive OPC UA alarms and events, measure how long states last, and send a message to the right channel when something changes.',
     summary: 'Alarm and event handling with Apache StreamPipes: receive OPC UA alarms and conditions, measure state durations, and send notifications to Slack, Teams, email or Telegram.',
     cover: {src: img('notification-pipeline'), alt: 'Pipeline sending notifications based on sensor events'},
     problem: [
-      'Alarm lists live in the SCADA system and rarely reach the people who need them on the phone. Nobody knows how long a machine stood still last week, or how often a warning repeated.',
-      'StreamPipes subscribes to OPC UA alarm and condition events, turns them into a stream, measures state durations and counts, and forwards messages to chat and email, with the history kept as a dataset for later analysis.',
+      'Alarm lists live in the SCADA system and rarely reach the people on the phone. Nobody can say how long a machine stood still last week, or how often a warning came back.',
+      'StreamPipes subscribes to OPC UA alarm and condition events, turns them into a stream, measures durations and counts, and sends messages to chat and email. The history ends up in a dataset you can look at later.',
     ],
     steps: [
       {title: 'Receive events', text: 'The OPC UA Events adapter subscribes to alarms and conditions and emits a flat event per notification. Choose the event type and the fields you need.'},
diff --git a/website-v2/src/pages/architecture.tsx b/website-v2/src/pages/architecture.tsx
index e7c8ade53..8e8825ea8 100644
--- a/website-v2/src/pages/architecture.tsx
+++ b/website-v2/src/pages/architecture.tsx
@@ -4,17 +4,17 @@ import {Bento, Button, Card, Container, DeploymentDiagram, FlowDiagram, Headline
 import styles from './pages.module.css';
 
 const components = [
-  {title: 'User interface', text: 'An Angular web application for everyday work: connecting sources, building pipelines, exploring datasets, creating charts and dashboards, managing assets, users and settings. It talks to the core over REST and can be extended with custom modules and themes.'},
-  {title: 'Core', text: 'The management and monitoring service. It stores metadata, validates and starts pipelines, monitors adapters and running components, serves the UI and the REST API, and handles users, roles, permissions and audit events.'},
-  {title: 'Messaging layer', text: 'An external broker carries every event between adapters, processors and sinks, so services stay decoupled. NATS is the lightweight default; Apache Kafka, MQTT and Apache Pulsar are supported where an organization standardizes on them.'},
-  {title: 'Extension services', text: 'Microservices that contribute adapters, processors, sinks and Functions. Several can register with one core, each with its own set of capabilities, deployed and updated independently and placed where the data is.'},
-  {title: 'Storage', text: 'A time-series database for datasets and historical analysis, and Apache CouchDB for configuration, metadata and user data. Both are part of the standard installation; retention and archival keep the time-series store under control.'},
-  {title: 'Clients and APIs', text: 'Java and Python clients, the REST API and Functions give external applications access to resources, live streams and pipeline lifecycles without going through the UI.'},
+  {title: 'User interface', text: 'An Angular web application for daily work: connecting sources, building pipelines, exploring datasets, creating charts and dashboards, managing assets, users and settings. It talks to the core over REST, and you can add your own modules and theme.'},
+  {title: 'Core', text: 'The service that manages and monitors everything else. It stores metadata, checks and starts pipelines, watches adapters and other running components, serves the UI and the REST API, and takes care of users, roles, permissions and the audit log.'},
+  {title: 'Messaging layer', text: 'A broker carries every event between adapters, processors and sinks, so no two services talk to each other directly. NATS is the default because it is small and copes well with being deployed near machines. Kafka, MQTT and Pulsar work too if that is what you already run.'},
+  {title: 'Extension services', text: 'Services that bring adapters, processors, sinks and Functions. Several can register with one core, each with its own set, and each is deployed and updated on its own, ideally close to the systems it talks to.'},
+  {title: 'Storage', text: 'A time-series database for datasets, and Apache CouchDB for configuration, metadata and user data. Both come with the standard installation. Retention rules keep the time-series database from growing without limit.'},
+  {title: 'Clients and APIs', text: 'Java and Python clients, the REST API and Functions let other applications read resources, subscribe to live streams and control pipelines without the UI.'},
 ];
 
 export default function Architecture() {
   return <Layout title="Architecture" description="How Apache StreamPipes is built: core, message broker, extension services, time-series storage and clients, and how they are deployed across OT and IT with Docker Compose or Kubernetes.">
-    <PageIntro eyebrow="Architecture" title="Built as services. Deployed where you need them." lead="StreamPipes is a set of cooperating services around a message broker. The core manages and monitors, extension services connect and process, storage keeps history and configuration. Each part runs where it fits: on one host for an evaluation, across plants and a data center in production." actions={<><Button to="/docs/concepts-architecture/">Architecture in the docs</Button><Button to="/d [...]
+    <PageIntro eyebrow="Architecture" title="How StreamPipes is built." lead="StreamPipes is a set of services around a message broker. The core manages and monitors, extension services connect and process, and two databases keep history and configuration. You decide where each part runs: all on one host to try it out, or spread across plants and a data center in production." actions={<><Button to="/docs/concepts-architecture/">Architecture in the docs</Button><Button to="/docs/configure [...]
     <Section tone="light" className={styles.compact}>
       <Container>
         <ScreenshotFrame src="/img/home/architecture.webp" alt="StreamPipes architecture: interfaces on top, the core and time-series database in the middle, a messaging layer, and extension services with adapters, processors, sinks and Functions connected to machines" width={1600} height={695} caption="Architecture overview" className={styles.diagramFrame} />
@@ -22,13 +22,13 @@ export default function Architecture() {
     </Section>
     <Section tone="tint" bordered>
       <Container>
-        <SectionHead eyebrow="Components" title={<>Six parts.<br />One platform.</>} lead="Every component has one job. Together they cover connectivity, processing, history, visualization and administration without a custom integration layer." />
+        <SectionHead eyebrow="Components" title={<>The parts.</>} lead="Each service has one job. Together they cover connecting, processing, storing, visualizing and administering, with no custom integration layer in between." />
         <div className={styles.componentList}>{components.map((c, i) => <div key={c.title} className={styles.componentRow}><span>{String(i + 1).padStart(2, '0')}</span><div><h3>{c.title}</h3><p>{c.text}</p></div></div>)}</div>
       </Container>
     </Section>
     <Section tone="light" bordered>
       <Container>
-        <SectionHead eyebrow="Data flow" title={<>From machine signal<br />to insight.</>} lead="Adapters turn raw signals into typed streams. Pipelines act on them in real time. Datasets keep the history. Charts and dashboards make it visible." />
+        <SectionHead eyebrow="Data flow" title={<>What happens<br />to an event.</>} lead="An adapter turns raw signals into a typed stream. Pipelines work on that stream as events arrive. Datasets keep what you want to look at later, and charts and dashboards show it." />
         <FlowDiagram nodes={[
           {label: 'Machines and systems', sub: 'OPC UA, S7, MQTT, Kafka'},
           {label: 'Connect', sub: 'Adapters, schemas, units'},
@@ -36,48 +36,48 @@ export default function Architecture() {
           {label: 'Datasets', sub: 'History and retention'},
           {label: 'Charts and dashboards', sub: 'Operators and teams'},
         ]} />
-        <p className={styles.note}>A stream is described once, with field types, measurement units and metadata. Every pipeline, chart and dashboard builds on that description, and the pipeline editor validates processors and sinks against it before anything runs.</p>
+        <p className={styles.note}>A stream is described once, with field types, measurement units and metadata. Every pipeline, chart and dashboard builds on that description, and the pipeline editor checks processors and sinks against it before anything runs.</p>
       </Container>
     </Section>
     <Section tone="tint" bordered>
       <Container>
-        <SectionHead eyebrow="Extension services" title={<>Add capabilities<br />without touching the core.</>} lead="Each extension service registers its adapters, processors, sinks and Functions with the core. Install the built-in ones at runtime, or build your own with the SDK and deploy them next to the systems they integrate." />
+        <SectionHead eyebrow="Extension services" title={<>New capabilities<br />without touching the core.</>} lead="Each extension service registers its adapters, processors, sinks and Functions with the core. The built-in ones install while the platform runs. Your own, written with the SDK, run next to the systems they talk to." />
         <ScreenshotFrame src="/img/home/extension-services.webp" alt="Multiple extension services at distributed locations registering with one StreamPipes core" width={1600} height={849} caption="Multiple extension services at distributed locations register with one core" className={styles.diagramFrame} />
         <div className={styles.actionsRow}><Button to="/integrations/" variant="ghost">Browse the built-in extensions</Button><Button to="/docs/extend-setup/" variant="ghost">Build your own</Button></div>
       </Container>
     </Section>
     <Section tone="light" bordered>
       <Container>
-        <SectionHead eyebrow="Deployment" title={<>Extension services at the edge.<br />One core to manage them.</>} lead="Each plant runs a small extension service next to its PLCs and machines. It connects outbound to the broker, so the OT network needs no inbound ports. Core, storage, processors and sinks stay in IT, managed from one place." />
+        <SectionHead eyebrow="Deployment" title={<>Extension services in the plant,<br />the core where your servers are.</>} lead="Each plant runs a small extension service next to its PLCs and machines. The service connects outbound to the broker, so you do not open any ports into the OT network. The core, the storage and the heavier processing stay in IT." />
         <div className={styles.diagramFrame}><DeploymentDiagram /></div>
         <div className={styles.stepsBlock}>
           <Steps items={[
-            {title: 'Run it where the data is', text: 'Place extension services in the OT network next to your equipment and keep the core in the data center or cloud. The broker connects both, with control flow only from IT to OT.'},
-            {title: 'Start small, grow in place', text: 'A single Docker Compose host is enough to evaluate. The same services scale out on Kubernetes with the Helm chart without changing your pipelines.'},
-            {title: 'Keep the data yours', text: 'Everything runs on your infrastructure. No usage metering, no proprietary formats: export datasets whenever you need.'},
+            {title: 'Run it where the data is', text: 'Put extension services into the plant network, next to the equipment, and keep the core in the data center or in the cloud. The broker connects the two.'},
+            {title: 'Start small, grow in place', text: 'One Docker Compose host is enough to try things out. The same services scale out on Kubernetes with the Helm chart later, and your pipelines stay as they are.'},
+            {title: 'The data stays yours', text: 'Everything runs on infrastructure you control. There is no usage metering and no proprietary format, and you can export a dataset whenever you want to.'},
           ]} />
         </div>
       </Container>
     </Section>
     <Section tone="tint" bordered>
       <Container>
-        <SectionHead eyebrow="Communication" title={<>HTTP or NATS<br />between core and extensions.</>} lead="In many OT environments, opening inbound ports to extension services is undesirable or impossible. StreamPipes supports NATS request-reply as the transport between core and extension services, so a service in a restricted network only needs an outbound connection to the broker." />
+        <SectionHead eyebrow="Communication" title={<>HTTP or NATS between<br />the core and the extensions.</>} lead="In many plants, opening an inbound port to a service is not an option. StreamPipes can route the traffic between the core and extension services through NATS instead of HTTP, so a service in a restricted network only ever connects outward." />
         <Bento>
-          <Card span={2} title="HTTP">The default for simple setups. The core calls extension services directly; suitable when all services share one network.</Card>
+          <Card span={2} title="HTTP">The default. The core calls extension services directly, which is fine when everything shares one network.</Card>
           <Card span={2} title="NATS">Core and extension services talk through the broker. No inbound ports on the extension side, optional token authentication, TLS on the connection.</Card>
-          <Card span={2} title="Dual and auto">Extension services can offer both; the core picks the transport that is available, which eases migrations between the modes.</Card>
+          <Card span={2} title="Dual and auto">Extension services can offer both, and the core uses whichever is available. Handy while you move from one mode to the other.</Card>
         </Bento>
       </Container>
     </Section>
     <Section tone="light" bordered>
       <Container>
         <div className={styles.twoCol}>
-          <div><Headline level={2}>Read the details.</Headline><Lead>The documentation covers every component, the data model, the deployment models and the configuration reference.</Lead></div>
+          <div><Headline level={2}>The details are in the docs.</Headline><Lead>Components, the data model, the deployment models and the full configuration reference.</Lead></div>
           <Bento>
             <Card span={3} to="/docs/concepts-architecture/" title="Architecture" link="Read">Components, data model, communication modes and implementation notes.</Card>
             <Card span={3} to="/docs/configure-operate-deployment/" title="Deployment" link="Read">Docker Compose, distributed setups, brokers, Kubernetes and the Helm chart.</Card>
             <Card span={3} to="/docs/configure-operate-environment-variables/" title="Environment variables" link="Read">Every setting for identity, storage, transport, security and tuning.</Card>
-            <Card span={3} to="/enterprise/" title="Enterprise readiness" link="Read">Identity, access control, audit log, data lifecycle and secured connections.</Card>
+            <Card span={3} to="/enterprise/" title="Enterprise readiness" link="Read">Single sign-on, permissions, audit log, retention and encrypted connections.</Card>
           </Bento>
         </div>
       </Container>
diff --git a/website-v2/src/pages/community/get-involved.tsx b/website-v2/src/pages/community/get-involved.tsx
index c432d13e8..5aae70c92 100644
--- a/website-v2/src/pages/community/get-involved.tsx
+++ b/website-v2/src/pages/community/get-involved.tsx
@@ -11,29 +11,29 @@ const repositories = [
 
 export default function GetInvolved() {
   return <Layout title="Get involved" description="Contribute code, documentation, ideas and feedback to Apache StreamPipes. Where to start, which channels to use, and the main repositories.">
-    <PageIntro eyebrow="Community" title="Get involved" lead="StreamPipes grows through its community. You do not need to start with a large feature: bug reports, documentation improvements, testing, UI refinements, example updates and small fixes all move the project forward." actions={<><Button href="https://github.com/apache/streampipes/issues" variant="secondary">Browse open issues</Button><Button href="https://github.com/apache/streampipes/discussions" variant="ghost">Start a discus [...]
+    <PageIntro eyebrow="Community" title="Get involved" lead="StreamPipes is built by its community. You do not need a big feature to get started: bug reports, better docs, testing, small UI fixes and updated examples all help." actions={<><Button href="https://github.com/apache/streampipes/issues" variant="secondary">Browse open issues</Button><Button href="https://github.com/apache/streampipes/discussions" variant="ghost">Start a discussion</Button></>} />
     <Section tone="light" className={styles.compact}>
       <Container>
         <NumberedList items={[
-          {title: 'Start with a discussion', children: <p>If you want feedback on an idea, need product context, or want to know whether work is already in progress, ask on the <a href="/community/mailing-lists/">mailing lists</a> or in <a href="https://github.com/apache/streampipes/discussions">GitHub Discussions</a> before opening a larger pull request.</p>},
-          {title: 'Pick an issue or report one', children: <p>Contributions often begin with an issue. Report bugs, propose improvements, or look for an existing task in the <a href="https://github.com/apache/streampipes/issues">issue tracker</a> that matches your interest.</p>},
-          {title: 'Open a pull request', children: <p>Open a focused pull request against the relevant repository and describe motivation, scope and follow-up work. Smaller, single-topic pull requests are easier to review and integrate.</p>},
+          {title: 'Start with a discussion', children: <p>Before you start on something larger, ask on the <a href="/community/mailing-lists/">mailing lists</a> or in <a href="https://github.com/apache/streampipes/discussions">GitHub Discussions</a>. You get feedback on the idea, and you find out whether someone is already working on it.</p>},
+          {title: 'Pick an issue or report one', children: <p>Many contributions start from an issue. Report a bug, propose an improvement, or pick an open issue in the <a href="https://github.com/apache/streampipes/issues">tracker</a> that matches what you know.</p>},
+          {title: 'Open a pull request', children: <p>Open a pull request against the right repository and explain what it changes and why. Small, focused pull requests get reviewed faster.</p>},
         ]} />
       </Container>
     </Section>
     <Section tone="tint" bordered>
       <Container>
-        <div className={styles.head}><Headline level={2}>Where things happen.</Headline><Lead>Choose the channel that fits the kind of contribution.</Lead></div>
+        <div className={styles.head}><Headline level={2}>Where things happen.</Headline><Lead>Pick the channel that fits what you want to do.</Lead></div>
         <Bento>
-          <Card span={2} to="/community/mailing-lists/" title="Mailing lists" link="Open mailing lists">Design discussions, contributor questions and decisions that should be easy to reference later. The Apache way.</Card>
-          <Card span={2} href="https://github.com/apache/streampipes/discussions" title="GitHub Discussions" link="Open discussions">Questions, ideas and early feedback when you want a low-friction conversation around a possible contribution.</Card>
-          <Card span={2} href="https://github.com/apache/streampipes/issues" title="GitHub Issues" link="Browse issues">Actionable bugs, feature requests and work items that should be tracked explicitly in the project backlog.</Card>
+          <Card span={2} to="/community/mailing-lists/" title="Mailing lists" link="Open mailing lists">Design discussions, contributor questions, and decisions that people should be able to find later. This is how Apache projects work.</Card>
+          <Card span={2} href="https://github.com/apache/streampipes/discussions" title="GitHub Discussions" link="Open discussions">Questions, ideas and early feedback, when you want a quick conversation before committing to anything.</Card>
+          <Card span={2} href="https://github.com/apache/streampipes/issues" title="GitHub Issues" link="Browse issues">Bugs, feature requests and tasks that should be tracked.</Card>
         </Bento>
       </Container>
     </Section>
     <Section tone="light" bordered>
       <Container>
-        <div className={styles.head}><Headline level={2}>Source code.</Headline><Lead>The main repositories for code, documentation and examples.</Lead></div>
+        <div className={styles.head}><Headline level={2}>Source code.</Headline><Lead>The repositories for code, documentation and examples.</Lead></div>
         <Table head={['Repository', 'What it contains', 'Link']} rows={repositories.map(([name, text, link]) => [<code>{name}</code>, text, <a href={link}>Open repository</a>])} />
       </Container>
     </Section>
diff --git a/website-v2/src/pages/community/mailing-lists.tsx b/website-v2/src/pages/community/mailing-lists.tsx
index c9c667512..824b49e02 100644
--- a/website-v2/src/pages/community/mailing-lists.tsx
+++ b/website-v2/src/pages/community/mailing-lists.tsx
@@ -14,16 +14,16 @@ const head = ['List', 'Subscribe', 'Unsubscribe', 'Post', 'Archive'];
 
 export default function MailingLists() {
   return <Layout title="Mailing lists" description="Subscribe to the Apache StreamPipes user and developer mailing lists to ask questions, follow development and take part in decisions.">
-    <PageIntro eyebrow="Community" title="Mailing lists" lead="Mailing lists are where Apache projects discuss and decide. Send an empty email to the subscribe address, confirm the reply, and you are in. Archives are public." />
+    <PageIntro eyebrow="Community" title="Mailing lists" lead="Apache projects discuss and decide on mailing lists. To subscribe, send an empty email to the subscribe address and confirm the reply. The archives are public." />
     <Section tone="light" className={styles.compact}>
       <Container>
-        <div className={styles.head}><Headline level={2}>Users</Headline><Lead>You use StreamPipes and have questions, problems or feature requests? The community answers on the user list.</Lead></div>
+        <div className={styles.head}><Headline level={2}>Users</Headline><Lead>Questions, problems, feature requests: the user list is where the community answers.</Lead></div>
         <Table head={head} rows={[list('users')]} />
       </Container>
     </Section>
     <Section tone="tint" bordered>
       <Container>
-        <div className={styles.head}><Headline level={2}>Developers</Headline><Lead>Interested in contributing? Subscribe to the developer list for design discussions and votes, and to the commits list to follow every change.</Lead></div>
+        <div className={styles.head}><Headline level={2}>Developers</Headline><Lead>Want to contribute? The dev list carries design discussions and votes. The commits list gets a mail for every change.</Lead></div>
         <Table head={head} rows={[list('dev'), list('commits')]} />
       </Container>
     </Section>
diff --git a/website-v2/src/pages/community/team.tsx b/website-v2/src/pages/community/team.tsx
index 73b56fc65..771b8d1a4 100644
--- a/website-v2/src/pages/community/team.tsx
+++ b/website-v2/src/pages/community/team.tsx
@@ -10,7 +10,7 @@ export default function Team() {
   const {siteConfig} = useDocusaurusContext();
   const team = (siteConfig.customFields as {team: Member[]}).team;
   return <Layout title="Team" description="Committers and PMC members of the Apache StreamPipes project.">
-    <PageIntro eyebrow="Community" title="Team" lead="Committers and members of the Project Management Committee (PMC). The list is ordered by contribution count in the main repository and updated periodically." />
+    <PageIntro eyebrow="Community" title="Team" lead="Committers and members of the Project Management Committee. The list is ordered by number of contributions to the main repository and refreshed from time to time." />
     <Section tone="light" className={styles.compact}>
       <Container>
         <div className={styles.teamGrid}>
@@ -21,7 +21,7 @@ export default function Team() {
             <span className={`${styles.role} ${member.pmc ? styles.rolePmc : ''}`}>{member.pmc ? 'PMC member' : 'Committer'}</span>
           </a>)}
         </div>
-        <Lead className={styles.teamNote}>Want to join? Sustained contributions of any kind, code, documentation, reviews or community support, are how committers are invited. Start on the <a href="/community/get-involved/">get involved</a> page.</Lead>
+        <Lead className={styles.teamNote}>Want to join? Committers are invited based on sustained contributions, whether code, documentation, reviews or helping others. The <a href="/community/get-involved/">get involved</a> page is the place to start.</Lead>
       </Container>
     </Section>
   </Layout>;
diff --git a/website-v2/src/pages/download.tsx b/website-v2/src/pages/download.tsx
index e8bbd3801..4cb5429ac 100644
--- a/website-v2/src/pages/download.tsx
+++ b/website-v2/src/pages/download.tsx
@@ -12,28 +12,28 @@ const compose = (ref: string) => `mkdir -p streampipes-${ref} && cd streampipes-
 
 export default function Download() {
   return <Layout title="Download" description="Download the Apache StreamPipes source release or start the latest release and nightly builds with a single Docker Compose command.">
-    <PageIntro eyebrow="Download" title="Install Apache StreamPipes" lead="The official source release is the standard path. For a quick evaluation, the Compose shortcuts below start a complete instance with one command. Docker with Compose on Linux, macOS or Windows is all you need." />
+    <PageIntro eyebrow="Download" title="Install Apache StreamPipes" lead="The source release is the official download. If you just want to try StreamPipes, the Compose commands further down start a complete instance in one go. You need Docker with Compose on Linux, macOS or Windows." />
     <Section tone="light" className={styles.compact}>
       <Container>
         <DownloadSection version={RELEASE.version} releaseDate={RELEASE.date} showMoreInfo />
-        <p className={styles.note}>Which docs apply? The <a href="/docs/0.98.0/user-guide-introduction/">0.98.0 documentation</a> matches this release. The default <a href="/docs/user-guide-introduction/">documentation</a> and the screenshots on this site describe the upcoming release, labelled "Next", which you can try with the nightly build below.</p>
+        <p className={styles.note}>A note on versions: the <a href="/docs/0.98.0/user-guide-introduction/">0.98.0 documentation</a> matches this release. The default <a href="/docs/user-guide-introduction/">documentation</a> and the screenshots on this site show the upcoming release, called Next, which you can run with the nightly build below.</p>
       </Container>
     </Section>
     <Section tone="tint" bordered>
       <Container>
-        <div className={styles.head}><Headline level={2}>One command, running instance.</Headline><Lead>Each shortcut creates a folder, downloads the Compose file and its environment file, and starts the default setup. Change the environment file before using an instance in production.</Lead></div>
+        <div className={styles.head}><Headline level={2}>One command, running instance.</Headline><Lead>Each command creates a folder, downloads the Compose file and the environment file, and starts the default setup. Edit the environment file before you use an instance for real.</Lead></div>
         <div className={styles.twoCol}>
-          <div><h3 className={styles.h3}>Latest release {RELEASE.version}</h3><p className={styles.p}>Pinned to the current release with the NATS-based default setup.</p><CodePanel title="docker compose" language="bash" code={compose(RELEASE.version)} wrap meta={`release ${RELEASE.version}`} /></div>
-          <div><h3 className={styles.h3}>Nightly build</h3><p className={styles.p}>Tracks the dev branch. No guarantees, and it can include breaking changes.</p><CodePanel title="docker compose" language="bash" code={compose('dev')} wrap meta="dev branch" /></div>
+          <div><h3 className={styles.h3}>Latest release {RELEASE.version}</h3><p className={styles.p}>The current release with the default NATS setup.</p><CodePanel title="docker compose" language="bash" code={compose(RELEASE.version)} wrap meta={`release ${RELEASE.version}`} /></div>
+          <div><h3 className={styles.h3}>Nightly build</h3><p className={styles.p}>Follows the dev branch. No guarantees, and things can break between builds.</p><CodePanel title="docker compose" language="bash" code={compose('dev')} wrap meta="dev branch" /></div>
         </div>
       </Container>
     </Section>
     <Section tone="light" bordered>
       <Container>
         <Bento>
-          <Card span={2} to="/docs/quick-start-guide/" title="After installation" link="Open the quickstart">Create your first adapter, persist a dataset, build a chart and place it on a dashboard.</Card>
-          <Card span={2} to="/docs/configure-operate-deployment/" title="Production deployments" link="Deployment options">Kubernetes with the Helm chart, Kafka instead of NATS, and extension services next to your machines.</Card>
-          <Card span={2} to="/docs/community-get-help/" title="Need help?" link="Support channels">GitHub Discussions, the user mailing list, and commercial support from companies around the project.</Card>
+          <Card span={2} to="/docs/quick-start-guide/" title="After installation" link="Open the quickstart">Create a first adapter, store its data, build a chart and put it on a dashboard.</Card>
+          <Card span={2} to="/docs/configure-operate-deployment/" title="Production deployments" link="Deployment options">Kubernetes with the Helm chart, Kafka instead of NATS, extension services next to the machines.</Card>
+          <Card span={2} to="/docs/community-get-help/" title="Need help?" link="Support channels">GitHub Discussions, the user mailing list, and companies that offer support contracts.</Card>
         </Bento>
       </Container>
     </Section>
diff --git a/website-v2/src/pages/enterprise.tsx b/website-v2/src/pages/enterprise.tsx
index 828e5e974..833702671 100644
--- a/website-v2/src/pages/enterprise.tsx
+++ b/website-v2/src/pages/enterprise.tsx
@@ -6,45 +6,45 @@ import styles from './pages.module.css';
 const topics = [
   {
     title: 'Single sign-on',
-    lead: 'Log in through the identity provider you already run.',
-    text: 'StreamPipes supports OpenID Connect and OAuth2. Configure one or more providers, such as Keycloak, Microsoft Entra ID or GitHub, through environment variables, map email, name and roles from token claims, and assign default roles to new users. Password login stays available alongside.',
+    lead: 'Sign in with the identity provider you already have.',
+    text: 'StreamPipes supports OpenID Connect and OAuth2. Providers such as Keycloak, Microsoft Entra ID or GitHub are configured through environment variables. You can set up several side by side, take email, name and roles from token claims, and give new users default roles. Password login stays available.',
     facts: ['OpenID Connect and OAuth2 providers', 'Several providers in parallel', 'Role mapping from token claims', 'Login method recorded in the audit log'],
     link: {label: 'Configure external identity providers', to: '/docs/configure-operate-security/'},
   },
   {
     title: 'Roles, groups and permissions',
-    lead: 'Fine-grained control over who sees and changes what.',
-    text: 'Built-in roles cover administrators, pipeline, dashboard, data explorer, connect and asset users; custom roles are composed from individual privileges. Groups make assignments reusable. Every resource has an owner and can be shared with users and groups, made public or exposed through a public link. Service accounts and API keys cover automation.',
+    lead: 'Decide who sees and changes what.',
+    text: 'Built-in roles cover administrators and the pipeline, dashboard, data explorer, connect and asset areas. Custom roles are put together from individual privileges, and groups make assignments reusable. Every resource has an owner and can be shared with users or groups, made public, or exposed through a link. Service accounts and API keys cover scripts and integrations.',
     facts: ['Built-in and custom roles from fine-grained privileges', 'User groups for reusable assignments', 'Per-resource permissions with owners and public links', 'Service accounts and API keys for automation'],
     link: {label: 'Security and user management', to: '/docs/configure-operate-security/'},
     image: {src: '/img/home/security-edit-roles.webp', alt: 'Role editor with available and selected privileges', caption: 'Custom roles are composed from individual privileges.'},
   },
   {
     title: 'Audit log',
-    lead: 'Who changed what, when, and how they signed in.',
-    text: 'The audit log records logins and logouts, adapter, dataset, chart and dashboard changes, exports and imports, file uploads, mail configuration and security group changes. Review it in the Configuration area with filters, download it as CSV, JSON or Excel, and apply retention rules that delete or archive older entries on a schedule.',
+    lead: 'A record of who changed what.',
+    text: 'The audit log records logins and logouts, changes to adapters, datasets, charts and dashboards, exports and imports, file uploads, mail settings and security groups. You read it in the Configuration area with filters, download it as CSV, JSON or Excel, and give it a retention rule so it does not grow forever.',
     facts: ['Logins, resource changes, exports, security changes', 'Filterable view in the Configuration area', 'Download as CSV, JSON or Excel', 'Retention with delete, archive or both'],
     link: {label: 'General settings and configuration', to: '/docs/configure-operate-general-settings/'},
   },
   {
     title: 'Data retention and archival',
-    lead: 'Keep the history you need, archive the rest.',
-    text: 'Each dataset gets its own retention policy: delete entries older than a threshold, archive them to an export provider, or both, on a daily, weekly or monthly schedule, or on demand. Export providers write to a local folder or to S3-compatible object storage. Any dataset exports to CSV, JSON or Excel.',
+    lead: 'Keep what you need, archive the rest.',
+    text: 'Each dataset gets its own retention policy: delete entries older than a threshold, archive them to an export provider, or both, on a daily, weekly or monthly schedule or whenever you trigger it. Export providers write to a local folder or to S3-compatible storage. Any dataset can be exported as CSV, JSON or Excel.',
     facts: ['Per-dataset policies: delete, archive or both', 'Daily, weekly, monthly or on demand', 'Archive to local folders or S3', 'Export as CSV, JSON or Excel'],
     link: {label: 'Datasets and retention', to: '/docs/use-datasets/'},
   },
   {
     title: 'Secured connections',
-    lead: 'TLS where data moves, encryption where secrets rest.',
-    text: 'The UI serves HTTPS, and the Kubernetes ingress supports TLS. Secrets stored in the platform are encrypted at rest. Certificates for OPC UA, MQTT and Kafka are managed in the Extension Services view, where server certificates are trusted or rejected and expiry alerts are sent by email. The OPC UA adapter can be restricted to secure endpoints only.',
+    lead: 'Encrypted on the wire and at rest.',
+    text: 'The UI serves HTTPS and the Kubernetes ingress supports TLS. Secrets stored in the platform are encrypted. Certificates for OPC UA, MQTT and Kafka are handled in the Extension Services view, where you trust or reject a server certificate and get an email before one expires. The OPC UA adapter can be limited to secure endpoints.',
     facts: ['HTTPS for the UI, TLS in the Kubernetes ingress', 'Encrypted secrets at rest', 'Certificate management with trust decisions and expiry alerts', 'Keystores and truststores for OPC UA, MQTT and Kafka'],
     link: {label: 'Extension services and certificates', to: '/docs/configure-operate-extension-services/'},
     image: {src: '/img/home/settings-extension-services.webp', alt: 'Extension services view with certificate management', caption: 'Certificates are trusted or rejected per extension service.'},
   },
   {
     title: 'Operations',
-    lead: 'Run it like any other service in your landscape.',
-    text: 'Adapters and pipelines expose metrics and logs in the UI, and a Prometheus endpoint feeds your monitoring. The Helm chart includes Prometheus and Grafana templates. Resources such as adapters, assets, dashboards, charts and files can be exported and imported between instances, and migrations run automatically when a new version is installed.',
+    lead: 'Operate it like your other services.',
+    text: 'Adapters and pipelines show metrics and logs in the UI, and a Prometheus endpoint feeds your monitoring. The Helm chart comes with Prometheus and Grafana templates. Adapters, assets, dashboards, charts and files can be exported and imported between instances, and migrations run on their own when you install a new version.',
     facts: ['Metrics and logs per adapter and pipeline', 'Prometheus endpoint, Helm chart with Prometheus and Grafana', 'Export and import of resources between instances', 'Automatic migrations on upgrade'],
     link: {label: 'Deploy and operate', to: '/docs/configure-operate-deployment/'},
   },
@@ -52,7 +52,7 @@ const topics = [
 
 export default function Enterprise() {
   return <Layout title="Enterprise readiness" description="Apache StreamPipes for enterprise use: single sign-on with OpenID Connect, roles and permissions, audit log, dataset retention and archival, secured connections and operations, all under the Apache license.">
-    <PageIntro eyebrow="Enterprise readiness" title="Ready for the plant. Ready for IT." lead="The controls an IT department expects, built into the open-source platform: identity, access control, audit trail, data lifecycle and secured connections. Everything is Apache licensed; nothing sits behind an enterprise tier." actions={<><Button to="/docs/configure-operate-security/">Security documentation</Button><Button to="/architecture/" variant="ghost">Architecture</Button></>} />
+    <PageIntro eyebrow="Enterprise readiness" title="The things IT will ask about." lead="Single sign-on, roles and permissions, an audit log, retention rules and encrypted connections are part of the platform. There is no separate enterprise edition; everything on this page is in the Apache-licensed release." actions={<><Button to="/docs/configure-operate-security/">Security documentation</Button><Button to="/architecture/" variant="ghost">Architecture</Button></>} />
     <Section tone="light" className={styles.compact}>
       <Container>
         <ScreenshotFrame src="/img/home/security-overview.webp" alt="Security overview with user accounts, service accounts, groups and roles" width={1440} height={747} caption="Security overview: user accounts, service accounts, groups and roles" priority />
@@ -76,7 +76,7 @@ export default function Enterprise() {
     </Section>)}
     <Section tone="light" bordered>
       <Container>
-        <SectionHead eyebrow="Also included" title={<>Small things<br />that matter in production.</>} />
+        <SectionHead eyebrow="Also included" title={<>Smaller things<br />you will still want.</>} />
         <Table head={['Capability', 'What it does']} rows={[
           ['Terms acknowledgment', 'Require users to accept terms of use after login, with your own title and text.'],
           ['Self-registration and password recovery', 'Toggle both in General Settings and define the default roles for new accounts.'],
@@ -90,10 +90,10 @@ export default function Enterprise() {
     <Section tone="tint" bordered>
       <Container>
         <div className={styles.twoCol}>
-          <div><Headline level={2}>Need more than community support?</Headline><Lead>The community answers on GitHub Discussions and the mailing lists. Companies around the project offer support, training and development with guaranteed response times.</Lead></div>
+          <div><Headline level={2}>If community support is not enough.</Headline><Lead>The community answers on GitHub Discussions and the mailing lists. Several companies around the project offer support contracts, training and development.</Lead></div>
           <Bento>
-            <Card span={3} to="/docs/community-get-help/" title="Support options" link="Read">Community channels and commercial support providers.</Card>
-            <Card span={3} to="/download/" title="Install StreamPipes" link="Download">Source release, Compose shortcuts and nightly builds.</Card>
+            <Card span={3} to="/docs/community-get-help/" title="Support options" link="Read">Community channels and companies that offer support.</Card>
+            <Card span={3} to="/download/" title="Install StreamPipes" link="Download">Source release, one-command Compose setup and nightly builds.</Card>
           </Bento>
         </div>
       </Container>
diff --git a/website-v2/src/pages/features.tsx b/website-v2/src/pages/features.tsx
index 9489ec8ca..327edca94 100644
--- a/website-v2/src/pages/features.tsx
+++ b/website-v2/src/pages/features.tsx
@@ -8,50 +8,50 @@ const img = (name: string) => `/img/home/${name}.webp`;
 
 const features = [
   {
-    id: 'connect', eyebrow: 'Connect', title: 'Bring your machines into the picture.',
-    text: 'Adapters connect industrial equipment, message brokers, databases, files and software systems. A guided setup shows incoming events before anything is saved, and the schema editor fixes field names, types, measurement units and metadata once, so every pipeline, chart and dashboard builds on the same description.',
+    id: 'connect', eyebrow: 'Connect', title: 'Get the data in.',
+    text: 'Adapters connect to machines, brokers, databases, files and other software. You see the incoming events before you save anything, and you set field names, types, measurement units and metadata once. Everything downstream uses that description.',
     facts: ['OPC UA with node browser and alarms, Siemens S7, Modbus and other PLC4X protocols', 'MQTT, Kafka, Pulsar, NATS, files, HTTP and database adapters', 'Live event preview, schema refinement and unit conversion', 'Adapter metrics, logs and lifecycle control'],
     shots: [{src: img('connect-create-select-adapter'), alt: 'Adapter library', caption: 'Pick an adapter from the library.'}, {src: img('connect-create-configure-schema-example'), alt: 'Schema editor with field types and units', caption: 'Refine the schema with types, units and metadata.'}],
     link: '/docs/use-connect/',
   },
   {
-    id: 'pipelines', eyebrow: 'Pipelines', title: 'Turn incoming events into actions.',
-    text: 'The visual editor connects streams, processors and sinks from left to right. Compatibility checks only allow elements that fit the incoming schema, each element is configured against the real fields, and a live preview shows the result. Pipelines run as monitored components with metrics and logs, and templates standardize recurring patterns.',
+    id: 'pipelines', eyebrow: 'Pipelines', title: 'Do something with the data as it arrives.',
+    text: 'The visual editor connects streams, processors and sinks from left to right. Only elements that fit the incoming schema can be attached, each one is configured against the real fields, and a live preview shows what comes out. Running pipelines report metrics and logs, and templates make recurring patterns easy to repeat.',
     facts: ['Filter, enrich, detect, aggregate and route in real time', 'Validated against the stream schema before it runs', 'Live preview, metrics and logs per pipeline', 'Templates and pipelines as code for reuse'],
-    shots: [{src: img('pipeline-editor-example'), alt: 'Pipeline editor with a trend detection and notification pipeline', caption: 'Detect a trend, notify a team, store the data.'}, {src: img('pipeline-details'), alt: 'Pipeline details with metrics and logs', caption: 'Operate pipelines from the details view.'}],
+    shots: [{src: img('pipeline-editor-example'), alt: 'Pipeline editor with a trend detection and notification pipeline', caption: 'A pipeline that detects a trend, notifies a team and stores the data.'}, {src: img('pipeline-details'), alt: 'Pipeline details with metrics and logs', caption: 'Operate pipelines from the details view.'}],
     link: '/docs/use-pipelines/',
   },
   {
-    id: 'datasets', eyebrow: 'Datasets', title: 'Make live data useful for the long run.',
-    text: 'Datasets are persisted streams. Check freshness and size, preview stored events, import CSV files when the live connection is not the start, and download data when it must leave the platform. Retention policies delete or archive older data on a schedule, with export providers that write to local folders or S3.',
+    id: 'datasets', eyebrow: 'Datasets', title: 'Keep the history.',
+    text: 'A dataset is a stream you chose to store. Check how fresh and how large it is, preview the stored events, import CSV files if the history did not start with a live connection, and download data when it has to leave the platform. Retention policies delete or archive old data on a schedule; export providers write to a local folder or to S3.',
     facts: ['Persist any stream with one setting', 'Import CSV, export CSV, JSON or Excel', 'Retention: delete, archive or both, daily to monthly', 'Permissions per dataset'],
     shots: [{src: img('dataset-overview'), alt: 'Dataset workspace', caption: 'One place for stored events, retention and export.'}, {src: img('dataset-export-provider-dialog-s3'), alt: 'S3 export provider configuration', caption: 'Archive to S3 with reusable export providers.'}],
     link: '/docs/use-datasets/',
   },
   {
-    id: 'charts', eyebrow: 'Charts', title: 'Ask better questions of your data.',
-    text: 'A chart starts with a dataset, becomes a query with fields, filters, grouping and aggregation, and ends in a visualization that matches the question. Time series, heatmaps, distributions, gauges, tables, status and traffic-light charts cover the typical industrial views.',
+    id: 'charts', eyebrow: 'Charts', title: 'Look at the data properly.',
+    text: 'A chart starts with a dataset. You build a query with fields, filters, grouping and aggregation, check the preview, and pick a chart type that fits the question. Time series, heatmaps, distributions, gauges, tables, status and traffic-light charts cover most of what a shop floor needs.',
     facts: ['Raw, aggregated and single-value queries', 'Fields, filters, grouping, order and time selection', 'Time series, heatmaps, histograms, gauges, tables and more', 'Saved charts are reused across dashboards'],
     shots: [{src: img('chart-timeseries'), alt: 'Time-series chart editor', caption: 'From a dataset to a query, from a query to a chart.'}, {src: img('chart-status-heatmap'), alt: 'Status heatmap chart', caption: 'Status heatmaps show state changes over time.'}],
     link: '/docs/use-charts/',
   },
   {
-    id: 'dashboards', eyebrow: 'Dashboards', title: 'Give your team a shared operational view.',
-    text: 'Dashboards arrange saved charts into one screen for a machine, a line or a process. Grid and slide views, shared time settings across charts, a kiosk mode for the shop floor, and links to assets make them easy to find and easy to keep on a wall.',
+    id: 'dashboards', eyebrow: 'Dashboards', title: 'One screen for the team.',
+    text: 'Dashboards put saved charts together for a machine, a line or a process. There are grid and slide layouts, a shared time range across all charts, a kiosk mode for the wall, and links to assets so people find the right dashboard.',
     facts: ['Grid or slide layouts', 'Shared time range across charts', 'Kiosk mode and cloning', 'Linked to assets and governed by permissions'],
-    shots: [{src: img('dashboard-create'), alt: 'Dashboard with gauge, chart and status indicator', caption: 'Individual charts, one coordinated view.'}, {src: img('dashboard-preview'), alt: 'Dashboard in preview mode', caption: 'Preview and kiosk mode for operators.'}],
+    shots: [{src: img('dashboard-create'), alt: 'Dashboard with gauge, chart and status indicator', caption: 'Several charts, one view with a shared time range.'}, {src: img('dashboard-preview'), alt: 'Dashboard in preview mode', caption: 'Preview and kiosk mode for operators.'}],
     link: '/docs/use-dashboards/',
   },
   {
-    id: 'assets', eyebrow: 'Assets and sites', title: 'Put every dataset in its industrial context.',
-    text: 'Model plants, lines, stations and machines as assets, place them at sites with locations, and link adapters, datasets, pipelines, charts and dashboards to them. Operators start from the machine they care about and find the resources that belong to it, on a map or in a table.',
+    id: 'assets', eyebrow: 'Assets and sites', title: 'Data in the context of the plant.',
+    text: 'Model plants, lines, stations and machines as assets, give them sites and locations, and attach the adapters, datasets, pipelines, charts and dashboards that belong to each. Operators start from the machine they care about, on a map or in a table, and find what goes with it.',
     facts: ['Nested assets and reusable site structures', 'Labels, custom fields and locations', 'Links to streams, datasets, pipelines, charts and dashboards', 'Map and table views on the home screen'],
-    shots: [{src: img('asset-asset-link-overview'), alt: 'Asset with linked resources', caption: 'Start from the machine, find its data.'}, {src: img('home-map'), alt: 'Home screen with assets on a map', caption: 'Assets and sites on the map.'}],
+    shots: [{src: img('asset-asset-link-overview'), alt: 'Asset with linked resources', caption: 'Start from the machine and find its data.'}, {src: img('home-map'), alt: 'Home screen with assets on a map', caption: 'Assets and sites on the map.'}],
     link: '/docs/use-assets/',
   },
   {
-    id: 'administration', eyebrow: 'Administration', title: 'Run it as a platform, not a tool.',
-    text: 'Install and update extensions at runtime, manage extension services and their certificates, configure users, roles, groups and permissions, set instance-wide options such as self-registration and terms of use, review the audit log, and export or import resources between instances.',
+    id: 'administration', eyebrow: 'Administration', title: 'Settings, users, extensions.',
+    text: 'Install and update extensions while the platform runs, manage extension services and their certificates, set up users, roles, groups and permissions, decide on self-registration and terms of use, read the audit log, and move resources between instances with export and import.',
     facts: ['Extensions installed and updated at runtime', 'Users, roles, groups, service accounts and API keys', 'Audit log, email templates, terms acknowledgment', 'Export and import of resources'],
     shots: [{src: img('settings-extensions'), alt: 'Extensions catalog in the configuration area', caption: 'Install adapters, processors and sinks at runtime.'}, {src: img('security-overview'), alt: 'Security overview', caption: 'Accounts, groups and roles in one place.'}],
     link: '/docs/configure-operate-general-settings/',
@@ -60,7 +60,7 @@ const features = [
 
 export default function Features() {
   return <Layout title="Features" description="Apache StreamPipes features: connect industrial data sources, build real-time pipelines, persist datasets with retention, create charts and dashboards, model assets and sites, and administer the platform.">
-    <PageIntro eyebrow="Features" title="One platform. The whole data journey." lead="From the first machine connection to the dashboard on the shop floor, every step is built in. This page walks through the modules of StreamPipes as they appear in the product; the documentation has the details for each." actions={<><Button to="/docs/quick-start-guide/">Try it with the quickstart</Button><Button to="/use-cases/" variant="ghost">See the use cases</Button></>} />
+    <PageIntro eyebrow="Features" title="From the first connection to the dashboard." lead="Connecting a machine, processing its data, storing it and charting it are modules of one product in StreamPipes. This page shows each of them as it appears in the UI. The documentation has the details." actions={<><Button to="/docs/quick-start-guide/">Try it with the quickstart</Button><Button to="/use-cases/" variant="ghost">See the use cases</Button></>} />
     <Section tone="light" className={styles.compact}>
       <Container>
         <nav className={styles.jumpList} aria-label="Features on this page">{features.map(f => <a key={f.id} href={`#${f.id}`}>{f.eyebrow}</a>)}</nav>
@@ -82,7 +82,7 @@ export default function Features() {
     </Section>)}
     <Section tone="tint" bordered>
       <Container>
-        <SectionHead eyebrow="Beyond the UI" title={<>Integrate. Automate.<br />Extend.</>} lead="Everything on this page is also reachable from code: Python and Java clients, the REST API, Functions for event-driven logic, and an SDK for your own adapters, processors and sinks." />
+        <SectionHead eyebrow="Beyond the UI" title={<>Also<br />from code.</>} lead="Everything on this page can be reached without the UI: Python and Java clients, the REST API, Functions, and an SDK for adapters, processors and sinks of your own." />
         <Bento>
           <Card span={2} to="/integrations/" title="Integrations" link="Browse the catalog">All adapters, processors and sinks that ship with the platform.</Card>
           <Card span={2} to="/#developers" title="Developer tools" link="Clients, Functions, SDK">Python and Java clients, Functions and the extension SDK.</Card>
diff --git a/website-v2/src/pages/integrations.tsx b/website-v2/src/pages/integrations.tsx
index da3663fa3..542c7b1f8 100644
--- a/website-v2/src/pages/integrations.tsx
+++ b/website-v2/src/pages/integrations.tsx
@@ -27,7 +27,7 @@ export default function Integrations() {
   }, [type, category, query]);
 
   return <Layout title="Integrations" description={`Browse all ${all.length} Apache StreamPipes extensions: ${counts.adapter} adapters for OPC UA, Siemens S7, Modbus, MQTT, Kafka and more, ${counts.processor} data processors and ${counts.sink} data sinks.`}>
-    <PageIntro eyebrow="Integrations" title="Everything StreamPipes connects to." lead={`${counts.adapter} adapters, ${counts.processor} data processors and ${counts.sink} data sinks ship with the platform and install at runtime. This list reflects the upcoming release. Need something else? Build it with the SDK.`} actions={<><Button to="/docs/extend-setup/" variant="secondary">Build your own extension</Button><Button to="/docs/configure-operate-extensions/" variant="ghost">How to instal [...]
+    <PageIntro eyebrow="Integrations" title="Everything StreamPipes connects to." lead={`${counts.adapter} adapters, ${counts.processor} data processors and ${counts.sink} data sinks come with the platform and install while it runs. This list is for the upcoming release. If something is missing, the SDK is there to build it.`} actions={<><Button to="/docs/extend-setup/" variant="secondary">Build your own extension</Button><Button to="/docs/configure-operate-extensions/" variant="ghost">H [...]
     <Section tone="light" className={styles.catalog}>
       <Container>
         <div className={styles.toolbar}>
@@ -56,7 +56,7 @@ export default function Integrations() {
             </Link>
           </li>)}
         </ul>
-        {items.length === 0 && <p className={styles.empty}>Nothing matches. Try another term, or <Link to="/docs/extend-setup/">build the extension you need</Link>.</p>}
+        {items.length === 0 && <p className={styles.empty}>Nothing matches. Try another term, or <Link to="/docs/extend-setup/">build the extension yourself</Link>.</p>}
       </Container>
     </Section>
   </Layout>;
diff --git a/website-v2/src/pages/use-cases/index.tsx b/website-v2/src/pages/use-cases/index.tsx
index 3200768ca..8c6ce501b 100644
--- a/website-v2/src/pages/use-cases/index.tsx
+++ b/website-v2/src/pages/use-cases/index.tsx
@@ -6,7 +6,7 @@ import styles from '../../components/usecases/usecases.module.css';
 
 export default function UseCases() {
   return <Layout title="Use cases" description="What teams build with Apache StreamPipes: condition monitoring with OPC UA, PLC data to Kafka and InfluxDB, MQTT and unified namespace, anomaly detection with Python, alarms and notifications.">
-    <PageIntro eyebrow="Use cases" title="What teams build with StreamPipes." lead="Five typical scenarios, each with the adapters, processors and sinks involved and the guide to follow. All of them run on the standard installation." actions={<><Button to="/docs/quick-start-guide/">Start with the quickstart</Button><Button to="/integrations/" variant="ghost">Browse integrations</Button></>} />
+    <PageIntro eyebrow="Use cases" title="What people build with StreamPipes." lead="Five scenarios we see often. Each page lists the adapters, processors and sinks involved and links to the guide. All of it runs on a standard installation." actions={<><Button to="/docs/quick-start-guide/">Start with the quickstart</Button><Button to="/integrations/" variant="ghost">Browse integrations</Button></>} />
     <Section tone="light" className={styles.compact}>
       <Container>
         <div className={styles.index}>