✔ Kriterierna för föreningar med högst arvode ✔ Så många har fortfarande 0 kronor i arvode ✔ Det är det genomsnittliga styrelsearvodet ✔ Experten: Mjuka faktorer som spelar in

<h4 class="wp-block-heading"><strong>✔ Så ser arvodet ut i andra föreningar ✔ Kriterierna för föreningar med högst arvode ✔ Så många har fortfarande 0 kronor i arvode ✔ Det är det genomsnittliga styrelsearvodet ✔ Experten: Mjuka faktorer som spelar in</strong></h4>



<h4 class="wp-block-heading"><strong>Med insamlad data för över 500 föreningar har vi analyserat hur arvoden har utvecklats – beroende på föreningarnas storlek och antal medlemmar. Vilka har höjt, och hur många delägare krävs för riktigt höga arvoden?  Resultaten ger en inblick i hur styrelsearvodet ser ut i dag – och hur det förändrats över tid. </strong></h4>







<p>Styrelsearvodet kan variera kraftigt mellan olika samfällighetsföreningar. Faktorer som engagemang, framtida arbetsbörda och omfattningen av det löpande arbetet måste vägas in – samtidigt driver samtiden fram ett skifte i både engagemang och intresse.&nbsp;</p>



<p>Det kan vara en känslig fråga, och många föreningar har än i dag en styrelse som inte får något arvode. Men trenden pekar bara åt ett håll, menar Markus Pålsson, Chef för verksamhetsinnovation och utveckling på SBC. Sjunkande engagemang tillsammans med höga förväntningar från medlemmar påverkar nivåerna på styrelsearvodet.</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p>– Vi har en generell förändring där hela föreningsvärlden förändras. Det är svårare att engagera personer i styrelsearbetet, och vill man ha kompetenta ledamöter behöver man förändra sitt framtidstänk. Sitter man som ledamot ska man ha ersättning för sitt ansvar, säger han.&nbsp;</p>



<p>Bostadsrättsföreningar har kommit en längre bit på vägen än samfällighetsföreningar. Men förflyttningen från eldsjälarna, som har sett till att föreningen flutit på de senaste 20 åren, till en mer samtida styrelse börjar synas även hos samfällighetsföreningar.&nbsp;&nbsp;</p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large is-resized"><img src="https://samfalligheterna.se/wp-content/uploads/2024/09/Markus-P-pa-SBC-821x1024.png" alt="" class="wp-image-16167" style="width:271px;height:auto"/><figcaption class="wp-element-caption">Markus Pålsson, Chef för verksamhetsinnovation och utveckling på SBC. FOTO: SBC</figcaption></figure>
</div>
</div>



<p>– Det sitter fortfarande många eldsjälar kvar där ute och de kommer nog inte göra några större förändringar. Frågan är vad som händer när en ny styrelse roteras in? Diskussionen om styrelsearvode kommer ofta upp då. Det kostar att ta hand om saker, och att någon ska göra det åt medlemmarna, det behöver man inse.&nbsp;</p>



<h2 class="wp-block-heading">Uppåtgående trend </h2>



<p>Statistiken visar en stadig ökning av det genomsnittliga styrelsearvodet, med en total procentuell ökning på cirka 34 procent sedan 2020. Samtidigt saknar fortfarande majoriteten av samfällighetsföreningar ett styrelsearvode som överstiger 999 kronor. </p>



<p>Föreningar med färre medlemmar har ett högre genomsnittligt arvode per delägare, visar statistiken. Högst snitt för &#8221;kronor per delägare&#8221; har föreningar i spannet 100-150 medlemmar med 184 kronor per medlem. </p>



<p>Föreningar med 50-100 medlemmar hade ett genomsnittligt arvode på 10.500 kronor, medan föreningar med fler än 400 medlemmar hade ett genomsnittligt arvode på 152.211 kr. Här ska dock tilläggas att anställda inte har sorterats ut, vilket drar upp snittet bland de större föreningarna. Exkluderar vi föreningar med förmodade anställda landet i stället det genomsnittligt arvode på 62.000 kronor.</p>



<p>21,31 procent av föreningarna har höjt sitt arvode sedan 2020, medan cirka 11 procent har sänkt det. Majoriteten, 67 procent , har lämnat arvodet oförändrat.</p>



<h4 class="wp-block-heading"><strong>Genomsnittligt styrelsearvode 2020-2023 </strong></h4>



<p><em>Linjediagrammet nedan visar vad det genomsnittliga styrelsearvodet per år (utbetald klumpsumma till hela styrelsen) har varit mellan 2020-2023. </em></p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:66.66%">
<!DOCTYPE html>
<html lang="sv">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Genomsnittligt styrelsearvode</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 0;
            padding: 20px;
            background-color: #f4f4f4;
        }

        .chart-container {
            max-width: 600px;
            margin: 20px auto;
            padding: 20px;
            background-color: #fff;
            border: 1px solid #d3d3d3; /* Ljusgrå ram */
            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1); /* Subtil skugga */
            text-align: left; /* Vänsterjustering */
        }

        canvas {
            width: 100%;
            height: auto;
            max-height: 400px; /* Lås max-höjd för diagrammet */
        }

        /* Responsiv design */
        @media screen and (max-width: 600px) {
            .chart-container {
                max-width: 100%;
                padding: 0 10px;
            }

            canvas {
                max-height: 300px; /* Minskar max-höjden på mindre skärmar */
            }
        }

    </style>
</head>
<body>

<div class="chart-container">
    <canvas id="arvodeChart"></canvas>
</div>

<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script>
    document.addEventListener("DOMContentLoaded", function () {
        const ctx = document.getElementById('arvodeChart').getContext('2d');

        const data = {
            labels: ['2020', '2021', '2022', '2023'],
            datasets: [{
                label: 'Genomsnittligt styrelsearvode (kr)',
                data: [13956.33, 16089.84, 17646.91, 18830.44],
                backgroundColor: 'rgba(75, 192, 192, 0.2)',
                borderColor: 'rgba(75, 192, 192, 1)',
                borderWidth: 2,
                fill: false,  // Ingen bakgrundsfyllnad
                tension: 0.1  // Ger en lätt kurva på linjen
            }]
        };

        const config = {
            type: 'line',  // Ändrat till linjediagram
            data: data,
            options: {
                responsive: true,
                maintainAspectRatio: false,
                scales: {
                    y: {
                        beginAtZero: true,
                        title: {  // Beskrivning av y-axeln
                            display: true,
                            text: 'Styrelsearvode (kr)',
                            font: {
                                size: 14,
                                weight: 'bold'
                            }
                        },
                        ticks: {
                            callback: function(value) {
                                return value.toLocaleString('sv-SE') + ' kr'; // Lägg till 'kr' efter varje värde
                            },
                            font: {
                                size: 12,
                                weight: '300'
                            },
                            color: '#000'
                        }
                    },
                    x: {
                        title: {  // Beskrivning av x-axeln
                            display: true,
                            text: 'År',
                            font: {
                                size: 14,
                                weight: 'bold'
                            }
                        },
                        ticks: {
                            font: {
                                size: 12,
                                weight: '300'
                            },
                            color: '#000'
                        }
                    }
                },
                plugins: {
                    legend: {
                        display: false
                    }
                }
            }
        };

        new Chart(ctx, config);
    });
</script>

</body>
</html>

</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:33.33%"></div>
</div>



<h4 class="wp-block-heading">Föreningens ekonomi spelar stor roll</h4>



<p>Dessutom spelar föreningens ekonomi in. I en samfällighet med låg omsättning blir ett styrelsearvode tydligare än i en förening med hög omsättning, oavsett om det speglar arbetsbördan och ansvarsbilden eller inte.</p>



<p>– Arvodet kanske blir en ganska stor del av föreningens kostnader, till skillnad från föreningar där arvodet försvinner i mängden, säger Markus Pålsson.</p>



<h4 class="wp-block-heading">Ideella rollen snart ett minne blott</h4>



<p>De klassiska hundåren i styrelsen, som varje medlem gör utan ersättning, är en förlegad strategi. Det har visserligen fungerat historiskt, men förutsättningarna är annorlunda idag jämfört med för 15 år sedan, menar Markus. Jobb, familj och andra intressen äter upp all tid – vilket gör att styrelsearbetet hamnar i kläm.&nbsp;</p>



<p>–&nbsp; Man måste börja leta i andra ändan och hitta rätt kompetens, och kanske betala ett styrelsearvode för det. Alla är inte heller lämpliga att sitta i styrelsen. Jag tror att någonstans hänger det här ihop i förflyttningen som vi har påbörjat, men inte kommit så långt i än, säger Markus och fortsätter:&nbsp;</p>



<p>– Har de (ledamöterna red anm.) lust att lägga all sin tid på samfälligheten, framförallt oavlönat? Hur mycket tid har man som privatperson över för det här, i förhållande till förflyttningen vi sett de senaste årtionden?&nbsp;</p>



<p>Det kan vara en känslig fråga. När frågan om styrelsearvode för samfällighetens styrelse lyfts på stämman är det inte ovanligt att tappa det sakliga, berättar Markus. Det som faktiskt ligger till grund för styrelsearvodet. Här gäller det att vara tydlig mot medlemmarna.&nbsp;</p>



<p>– Det blir alltid en känslofråga på stämman när vi pratar arvode. Därför är det viktigt att verkligen motivera varför det är en skälig förändring. Det kanske är redovisning av nedlagda timmar, ett större ansvar och arbetet man faktiskt gör. Argumentera ordentligen varför en höjning är nödvändigt, helt enkelt, säger Markus Pålsson.&nbsp;</p>



<h4 class="wp-block-heading">Formulera information på ett bra sätt</h4>



<p>Går man från att inte ha något arvode till att rösta igenom ett styrelsearvode kan även den lägsta summan låta som hög. När man vid årsstämman presenterar förslaget kan det därför vara bra att bryta ner summan så långt det går. Ett timarvode på 15 kronor är svårare att argumentera mot än en klumpsumma på 50.000 kronor.&nbsp;</p>



<p>– Andelsägare kanske tycker att det låter som jättemycket pengar, men om man säger något i stil med att ‘vi har analyserat ansvarsområden och nedlagda timmar vilket motsvarar den här timersättningen’ så blir det ofta ett ganska lågt arvode. Ingen blir rik på det här.&nbsp;</p>



<h4 class="wp-block-heading"><strong>Går det att använda någon måttstock för att bestämma styrelsearvode?&nbsp;</strong></h4>



<p>– Grundfrågan är alltid vad ett skäligt arvode är. Många samfälligheter har ju inte ens ett styrelsearvode idag. Men jag gillar väl att koppla det till något typ av index, till exempel prisbasbeloppet.&nbsp;</p>



<h1 class="wp-block-heading"><strong>Statistik: Så ser styrelsearvodet ut</strong></h1>



<p>Genom att aggregera statistik från Lantmäteriet och Skattemyndigheten har vi kartlagt hur styrelsearvodet ser ut i landets samfällighetsföreningar. Vi kan se samband som ett högre arvode för större föreningar, och en uppåtgående trend i arvodesnivåer. </p>



<h3 class="wp-block-heading"><strong>Utveckling av styrelsearvode 2020-2023</strong></h3>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<!DOCTYPE html>
<html lang="sv">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Genomsnittligt styrelsearvode per år</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 0;
            padding: 30px;
            background-color: #f4f4f4;
        }

        .chart-container {
            max-width: 600px;
            margin: 40px auto;
            padding: 20px;
            background-color: #fff;
            border: 1px solid #d3d3d3; /* Ljusgrå ram */
            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1); /* Subtil skugga */
        }

        canvas {
            width: 100%;
            height: auto;
            max-height: 400px; /* Lås max-höjd för diagrammet */
        }

        /* Responsiv design */
        @media screen and (max-width: 600px) {
            .chart-container {
                max-width: 100%;
                padding: 0 10px;
            }

            canvas {
                max-height: 300px; /* Minskar max-höjden på mindre skärmar */
            }
        }

    </style>
</head>
<body>

<div class="chart-container">
    <canvas id="arvodeBarChart"></canvas>
</div>

<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script>
    document.addEventListener("DOMContentLoaded", function () {
        const ctx = document.getElementById('arvodeBarChart').getContext('2d');

        const data = {
            labels: ['2020', '2021', '2022', '2023'],
            datasets: [{
                label: 'Genomsnittligt styrelsearvode (kr)',
                data: [13956.33, 16089.84, 17646.91, 18830.44],
                backgroundColor: 'rgba(75, 192, 192, 0.2)',
                borderColor: 'rgba(75, 192, 192, 1)',
                borderWidth: 1
            }]
        };

        const config = {
            type: 'bar',
            data: data,
            options: {
                indexAxis: 'y',  // Gör stapeldiagrammet horisontellt
                responsive: true,
                maintainAspectRatio: false,
                scales: {
                    x: {
                        beginAtZero: true,
                        title: {  // Beskrivning av x-axeln
                            display: true,
                            text: '',
                            font: {
                                size: 14,
                                weight: 'bold'
                            }
                        },
                        ticks: {
                            callback: function(value) {
                                return value.toLocaleString('sv-SE') + ' kr'; // Lägg till 'kr' efter varje värde
                            },
                            font: {
                                size: 12,
                                weight: '300'
                            },
                            color: '#000'
                        }
                    },
                    y: {
                        title: {  // Beskrivning av y-axeln
                            display: true,
                            text: '',
                            font: {
                                size: 14,
                                weight: 'bold'
                            }
                        },
                        ticks: {
                            font: {
                                size: 12,
                                weight: '300'
                            },
                            color: '#000'
                        }
                    }
                },
                plugins: {
                    legend: {
                        display: false
                    }
                }
            }
        };

        new Chart(ctx, config);
    });
</script>

</body>
</html>




<p><em>Tabellen visar utvecklingen av det genomsnittliga styrelsearvodet över tid. Beloppen representerar den totala summan som betalats ut till hela styrelsen, inte per individ, utan som en sammanlagd ersättning för samtliga styrelsemedlemmar.</em></p>
</div>
</div>



<h3 class="wp-block-heading">Styrelsearvode beroende på antalet delägare </h3>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<!DOCTYPE html>
<html lang="sv">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Genomsnittligt styrelsearvode per antal medlemmar 2023</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 0;
            padding: 20px;
            background-color: #f4f4f4;
        }

        .chart-container {
            max-width: 600px;
            margin: 20px auto;
            padding: 20px;
            background-color: #fff;
            border: 1px solid #d3d3d3; /* Ljusgrå ram */
            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1); /* Subtil skugga */
        }

        canvas {
            width: 100%;
            height: auto;
            max-height: 400px; /* Lås max-höjd för diagrammet */
        }

        /* Responsiv design */
        @media screen and (max-width: 600px) {
            .chart-container {
                max-width: 100%;
                padding: 0 10px;
            }

            canvas {
                max-height: 300px; /* Minskar max-höjden på mindre skärmar */
            }
        }

    </style>
</head>
<body>

<div class="chart-container">
    <canvas id="medlemArvodeChart"></canvas>
</div>

<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script>
    document.addEventListener("DOMContentLoaded", function () {
        const ctx = document.getElementById('medlemArvodeChart').getContext('2d');

        const data = {
            labels: ['50-100', '100-150', '150-250', '250-400', '400+'],
            datasets: [{
                label: 'Genomsnittligt styrelsearvode 2023 (kr)',
                data: [10453.48, 26129.27, 30590.75, 39698.32, 62053.70],
                backgroundColor: 'rgba(75, 192, 192, 0.2)',
                borderColor: 'rgba(75, 192, 192, 1)',
                borderWidth: 1
            }]
        };

        const config = {
            type: 'bar',
            data: data,
            options: {
                responsive: true,
                maintainAspectRatio: false,
                scales: {
                    y: {
                        beginAtZero: true,
                        title: {  // Beskrivning av y-axeln
                            display: true,
                            text: '',
                            font: {
                                size: 14,
                                weight: 'bold'
                            }
                        },
                        ticks: {
                            callback: function(value) {
                                return value.toLocaleString('sv-SE') + ' kr'; // Lägg till 'kr' efter varje värde
                            },
                            font: {
                                size: 12,  // Mindre och tunnare text
                                weight: '300'
                            },
                            color: '#000'
                        }
                    },
                    x: {
                        title: {  // Beskrivning av x-axeln
                            display: true,
                            text: 'Antal medlemmar',
                            font: {
                                size: 14,
                                weight: 'bold'
                            }
                        },
                        ticks: {
                            font: {
                                size: 12,  // Mindre och tunnare text
                                weight: '300'
                            },
                            color: '#000'
                        }
                    }
                },
                plugins: {
                    legend: {
                        display: false
                    }
                }
            }
        };

        new Chart(ctx, config);
    });
</script>

</body>
</html>

</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p><em>Tabellen nedan visar hur styrelsearvodet skiljer sig åt beroende på hur många delägare samfällighetsföreningen har. Det är alltså totalt utbetalt arvode (2023).  Vi har även rensat föreningar som med stor sannolik har anställt personer. </em></p>
</div>
</div>



<h3 class="wp-block-heading"><strong>Styrelsearvode per delägare</strong></h3>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<!DOCTYPE html>
<html lang="sv">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Kronor per delägare per antal medlemmar 2023</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 0;
            padding: 20px;
            background-color: #f4f4f4;
        }

        .chart-container {
            max-width: 600px;
            margin: 20px auto;
            padding: 20px;
            background-color: #fff;
            border: 1px solid #d3d3d3; /* Ljusgrå ram */
            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1); /* Subtil skugga */
        }

        canvas {
            width: 100%;
            height: auto;
            max-height: 400px; /* Lås max-höjd för diagrammet */
        }

        /* Responsiv design */
        @media screen and (max-width: 600px) {
            .chart-container {
                max-width: 100%;
                padding: 0 10px;
            }

            canvas {
                max-height: 300px; /* Minskar max-höjden på mindre skärmar */
            }
        }

    </style>
</head>
<body>

<div class="chart-container">
    <canvas id="delagareChart"></canvas>
</div>

<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script>
    document.addEventListener("DOMContentLoaded", function () {
        const ctx = document.getElementById('delagareChart').getContext('2d');

        const data = {
            labels: ['50-100', '100-150', '150-250', '250-400', '400+'],
            datasets: [{
                label: 'Kronor per delägare 2023 (kr)',
                data: [122.29, 184.88, 167.62, 116.32, 67.93],
                backgroundColor: 'rgba(75, 192, 192, 0.2)',
                borderColor: 'rgba(75, 192, 192, 1)',
                borderWidth: 1
            }]
        };

        const config = {
            type: 'bar',
            data: data,
            options: {
                responsive: true,
                maintainAspectRatio: false,
                scales: {
                    y: {
                        beginAtZero: true,
                        title: {  // Beskrivning av y-axeln
                            display: true,
                            text: '',
                            font: {
                                size: 14,
                                weight: 'bold'
                            }
                        },
                        ticks: {
                            callback: function(value) {
                                return value.toLocaleString('sv-SE') + ' kr'; // Lägg till 'kr' efter varje värde
                            },
                            font: {
                                size: 12,  // Mindre och tunnare text
                                weight: '300'
                            },
                            color: '#000'
                        }
                    },
                    x: {
                        title: {  // Beskrivning av x-axeln
                            display: true,
                            text: 'Antal medlemmar',
                            font: {
                                size: 14,
                                weight: 'bold'
                            }
                        },
                        ticks: {
                            font: {
                                size: 12,  // Mindre och tunnare text
                                weight: '300'
                            },
                            color: '#000'
                        }
                    }
                },
                plugins: {
                    legend: {
                        display: false
                    }
                }
            }
        };

        new Chart(ctx, config);
    });
</script>

</body>
</html>

</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p><em>Stapeldiagrammet visar genomsnittligt arvode per delägare beroende på antalet medlemmar i föreningen för år 2023.</em></p>
</div>
</div>
</div>
</div>



<h3 class="wp-block-heading"><strong>Styrelsearvode beroende på antalet delägare</strong></h3>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<!DOCTYPE html>
<html lang="sv">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Förändring av arvode sedan 2020</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 0;
            padding: 20px;
            background-color: #f4f4f4;
        }

        .chart-container {
            max-width: 600px;
            margin: 20px auto;
            padding: 20px;
            background-color: #fff;
            border: 1px solid #d3d3d3; /* Ljusgrå ram */
            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1); /* Subtil skugga */
        }

        canvas {
            width: 100%;
            height: auto;
            max-height: 400px; /* Lås max-höjd för diagrammet */
            display: block;  /* För att säkerställa att det hanteras som ett blockelement */
        }

        /* Responsiv design */
        @media screen and (max-width: 600px) {
            .chart-container {
                max-width: 100%;
                padding: 0 10px;
            }

            canvas {
                max-height: 300px; /* Minskar max-höjden på mindre skärmar */
            }
        }

    </style>
</head>
<body>

<div class="chart-container">
    <canvas id="arvodePieChart"></canvas>
</div>

<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script>
    document.addEventListener("DOMContentLoaded", function () {
        const ctx = document.getElementById('arvodePieChart').getContext('2d');

        const data = {
            labels: ['Höjt arvode', 'Sänkt arvode', 'Oförändrat arvode'],
            datasets: [{
                data: [21.31, 10.96, 67.33],  // Procentandelar
                backgroundColor: [
                    'rgba(75, 192, 192, 0.6)',
                    'rgba(255, 159, 64, 0.6)',
                    'rgba(153, 102, 255, 0.6)'
                ],
                borderColor: [
                    'rgba(75, 192, 192, 1)',
                    'rgba(255, 159, 64, 1)',
                    'rgba(153, 102, 255, 1)'
                ],
                borderWidth: 1
            }]
        };

        const config = {
            type: 'pie',
            data: data,
            options: {
                responsive: true,
                maintainAspectRatio: false,
                plugins: {
                    legend: {
                        display: true,
                        position: 'bottom',
                        labels: {
                            font: {
                                size: 12,  // Mindre och tunnare text
                                weight: '300'
                            },
                            color: '#000'
                        }
                    }
                }
            }
        };

        const arvodePieChart = new Chart(ctx, config);
    });
</script>

</body>
</html>

</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p><em>Cirkeldiagrammet visar hur stor andel av föreningarna som har höjt, sänkt eller lämnat sitt arvode oförändrat. Diagrammet ger en överblick över förändringarna i arvodena där majoriteten av föreningarna har lämnat arvodet oförändrat, medan en mindre andel har valt att höja eller sänka det.</em></p>
</div>
</div>
</div>
</div>



<h4 class="wp-block-heading"><strong>Om undersökningen:</strong></h4>



<p>Undersökningen bygger på data från 502 samfällighetsföreningar, som valdes ut slumpmässigt men med kriterier gällande antalet delägare i varje förening. Undersökningen fokuserar enbart på föreningarnas styrelsearvoden och deras utveckling över tid. Uppgifterna samlades in under augusti 2024, och all data härstammar från Lantmäteriet och Skatteverket. Informationen har aggregats för att kunna presenteras i denna rapport.</p>



<p>Det är viktigt att notera att urvalet kanske inte är helt representativt för alla samfällighetsföreningar i Sverige. Det bör noteras att föreningar med över 400 delägare är underrepresenterade i jämförelse med föreningar i intervallet 50-250 delägare, vilket kan påverka balansen i resultaten. Vidare har vissa av de större föreningarna anställda, vilket påverkar deras utbetalade styrelsearvoden och kan leda till ett högre genomsnitt inom de större medlemskategorierna.</p>



<p></p>

