diff --git a/arrow-array/src/builder/fixed_size_binary_builder.rs b/arrow-array/src/builder/fixed_size_binary_builder.rs
index b5f268917c92..8fd6b72c053b 100644
--- a/arrow-array/src/builder/fixed_size_binary_builder.rs
+++ b/arrow-array/src/builder/fixed_size_binary_builder.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::builder::{ArrayBuilder, UInt8BufferBuilder};
+use crate::builder::ArrayBuilder;
 use crate::{ArrayRef, FixedSizeBinaryArray};
 use arrow_buffer::Buffer;
 use arrow_buffer::NullBufferBuilder;
@@ -42,7 +42,7 @@ use std::sync::Arc;
 /// ```
 #[derive(Debug)]
 pub struct FixedSizeBinaryBuilder {
-    values_builder: UInt8BufferBuilder,
+    values_builder: Vec<u8>,
     null_buffer_builder: NullBufferBuilder,
     value_length: i32,
 }
@@ -61,7 +61,7 @@ impl FixedSizeBinaryBuilder {
             "value length ({byte_width}) of the array must >= 0"
         );
         Self {
-            values_builder: UInt8BufferBuilder::new(capacity * byte_width as usize),
+            values_builder: Vec::with_capacity(capacity * byte_width as usize),
             null_buffer_builder: NullBufferBuilder::new(capacity),
             value_length: byte_width,
         }
@@ -79,7 +79,7 @@ impl FixedSizeBinaryBuilder {
                     .to_string(),
             ))
         } else {
-            self.values_builder.append_slice(value.as_ref());
+            self.values_builder.extend_from_slice(value.as_ref());
             self.null_buffer_builder.append_non_null();
             Ok(())
         }
@@ -89,7 +89,7 @@ impl FixedSizeBinaryBuilder {
     #[inline]
     pub fn append_null(&mut self) {
         self.values_builder
-            .append_slice(&vec![0u8; self.value_length as usize][..]);
+            .extend(std::iter::repeat_n(0u8, self.value_length as usize));
         self.null_buffer_builder.append_null();
     }
 
@@ -97,7 +97,7 @@ impl FixedSizeBinaryBuilder {
     #[inline]
     pub fn append_nulls(&mut self, n: usize) {
         self.values_builder
-            .append_slice(&vec![0u8; self.value_length as usize * n][..]);
+            .extend(std::iter::repeat_n(0u8, self.value_length as usize * n));
         self.null_buffer_builder.append_n_nulls(n);
     }
 
@@ -110,7 +110,7 @@ impl FixedSizeBinaryBuilder {
     pub fn finish(&mut self) -> FixedSizeBinaryArray {
         let array_length = self.len();
         let array_data_builder = ArrayData::builder(DataType::FixedSizeBinary(self.value_length))
-            .add_buffer(self.values_builder.finish())
+            .add_buffer(std::mem::take(&mut self.values_builder).into())
             .nulls(self.null_buffer_builder.finish())
             .len(array_length);
         let array_data = unsafe { array_data_builder.build_unchecked() };
diff --git a/arrow-array/src/builder/generic_bytes_builder.rs b/arrow-array/src/builder/generic_bytes_builder.rs
index 91ac2a483ef4..c2c743e3ab27 100644
--- a/arrow-array/src/builder/generic_bytes_builder.rs
+++ b/arrow-array/src/builder/generic_bytes_builder.rs
@@ -15,11 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::builder::{ArrayBuilder, BufferBuilder, UInt8BufferBuilder};
+use crate::builder::ArrayBuilder;
 use crate::types::{ByteArrayType, GenericBinaryType, GenericStringType};
 use crate::{Array, ArrayRef, GenericByteArray, OffsetSizeTrait};
-use arrow_buffer::NullBufferBuilder;
-use arrow_buffer::{ArrowNativeType, Buffer, MutableBuffer};
+use arrow_buffer::{ArrowNativeType, Buffer, MutableBuffer, NullBufferBuilder, ScalarBuffer};
 use arrow_data::ArrayDataBuilder;
 use std::any::Any;
 use std::sync::Arc;
@@ -29,8 +28,8 @@ use std::sync::Arc;
 /// For building strings, see docs on [`GenericStringBuilder`].
 /// For building binary, see docs on [`GenericBinaryBuilder`].
 pub struct GenericByteBuilder<T: ByteArrayType> {
-    value_builder: UInt8BufferBuilder,
-    offsets_builder: BufferBuilder<T::Offset>,
+    value_builder: Vec<u8>,
+    offsets_builder: Vec<T::Offset>,
     null_buffer_builder: NullBufferBuilder,
 }
 
@@ -47,10 +46,10 @@ impl<T: ByteArrayType> GenericByteBuilder<T> {
     /// - `data_capacity` is the total number of bytes of data to pre-allocate
     ///   (for all items, not per item).
     pub fn with_capacity(item_capacity: usize, data_capacity: usize) -> Self {
-        let mut offsets_builder = BufferBuilder::<T::Offset>::new(item_capacity + 1);
-        offsets_builder.append(T::Offset::from_usize(0).unwrap());
+        let mut offsets_builder = Vec::with_capacity(item_capacity + 1);
+        offsets_builder.push(T::Offset::from_usize(0).unwrap());
         Self {
-            value_builder: UInt8BufferBuilder::new(data_capacity),
+            value_builder: Vec::with_capacity(data_capacity),
             offsets_builder,
             null_buffer_builder: NullBufferBuilder::new(item_capacity),
         }
@@ -67,8 +66,9 @@ impl<T: ByteArrayType> GenericByteBuilder<T> {
         value_buffer: MutableBuffer,
         null_buffer: Option<MutableBuffer>,
     ) -> Self {
-        let offsets_builder = BufferBuilder::<T::Offset>::new_from_buffer(offsets_buffer);
-        let value_builder = BufferBuilder::<u8>::new_from_buffer(value_buffer);
+        let offsets_builder: Vec<T::Offset> =
+            ScalarBuffer::<T::Offset>::from(offsets_buffer).into();
+        let value_builder: Vec<u8> = ScalarBuffer::<u8>::from(value_buffer).into();
 
         let null_buffer_builder = null_buffer
             .map(|buffer| NullBufferBuilder::new_from_buffer(buffer, offsets_builder.len() - 1))
@@ -103,9 +103,10 @@ impl<T: ByteArrayType> GenericByteBuilder<T> {
     /// [`BinaryArray`]: crate::BinaryArray
     #[inline]
     pub fn append_value(&mut self, value: impl AsRef<T::Native>) {
-        self.value_builder.append_slice(value.as_ref().as_ref());
+        self.value_builder
+            .extend_from_slice(value.as_ref().as_ref());
         self.null_buffer_builder.append(true);
-        self.offsets_builder.append(self.next_offset());
+        self.offsets_builder.push(self.next_offset());
     }
 
     /// Append an `Option` value into the builder.
@@ -126,7 +127,7 @@ impl<T: ByteArrayType> GenericByteBuilder<T> {
     #[inline]
     pub fn append_null(&mut self) {
         self.null_buffer_builder.append(false);
-        self.offsets_builder.append(self.next_offset());
+        self.offsets_builder.push(self.next_offset());
     }
 
     /// Appends `n` `null`s into the builder.
@@ -134,7 +135,8 @@ impl<T: ByteArrayType> GenericByteBuilder<T> {
     pub fn append_nulls(&mut self, n: usize) {
         self.null_buffer_builder.append_n_nulls(n);
         let next_offset = self.next_offset();
-        self.offsets_builder.append_n(n, next_offset);
+        self.offsets_builder
+            .extend(std::iter::repeat_n(next_offset, n));
     }
 
     /// Appends array values and null to this builder as is
@@ -150,7 +152,7 @@ impl<T: ByteArrayType> GenericByteBuilder<T> {
         // If the offsets are contiguous, we can append them directly avoiding the need to align
         // for example, when the first appended array is not sliced (starts at offset 0)
         if self.next_offset() == offsets[0] {
-            self.offsets_builder.append_slice(&offsets[1..]);
+            self.offsets_builder.extend_from_slice(&offsets[1..]);
         } else {
             // Shifting all the offsets
             let shift: T::Offset = self.next_offset() - offsets[0];
@@ -164,11 +166,11 @@ impl<T: ByteArrayType> GenericByteBuilder<T> {
                 intermediate.push(offset + shift)
             }
 
-            self.offsets_builder.append_slice(&intermediate);
+            self.offsets_builder.extend_from_slice(&intermediate);
         }
 
         // Append underlying values, starting from the first offset and ending at the last offset
-        self.value_builder.append_slice(
+        self.value_builder.extend_from_slice(
             &array.values().as_slice()[offsets[0].as_usize()..offsets[array.len()].as_usize()],
         );
 
@@ -184,11 +186,11 @@ impl<T: ByteArrayType> GenericByteBuilder<T> {
         let array_type = T::DATA_TYPE;
         let array_builder = ArrayDataBuilder::new(array_type)
             .len(self.len())
-            .add_buffer(self.offsets_builder.finish())
-            .add_buffer(self.value_builder.finish())
+            .add_buffer(std::mem::take(&mut self.offsets_builder).into())
+            .add_buffer(std::mem::take(&mut self.value_builder).into())
             .nulls(self.null_buffer_builder.finish());
 
-        self.offsets_builder.append(self.next_offset());
+        self.offsets_builder.push(self.next_offset());
         let array_data = unsafe { array_builder.build_unchecked() };
         GenericByteArray::from(array_data)
     }
@@ -340,7 +342,7 @@ pub type GenericStringBuilder<O> = GenericByteBuilder<GenericStringType<O>>;
 
 impl<O: OffsetSizeTrait> std::fmt::Write for GenericStringBuilder<O> {
     fn write_str(&mut self, s: &str) -> std::fmt::Result {
-        self.value_builder.append_slice(s.as_bytes());
+        self.value_builder.extend_from_slice(s.as_bytes());
         Ok(())
     }
 }
@@ -394,7 +396,7 @@ pub type GenericBinaryBuilder<O> = GenericByteBuilder<GenericBinaryType<O>>;
 
 impl<O: OffsetSizeTrait> std::io::Write for GenericBinaryBuilder<O> {
     fn write(&mut self, bs: &[u8]) -> std::io::Result<usize> {
-        self.value_builder.append_slice(bs);
+        self.value_builder.extend_from_slice(bs);
         Ok(bs.len())
     }
 
diff --git a/arrow-array/src/builder/generic_list_builder.rs b/arrow-array/src/builder/generic_list_builder.rs
index 463b498c55ba..4d044ca35e2a 100644
--- a/arrow-array/src/builder/generic_list_builder.rs
+++ b/arrow-array/src/builder/generic_list_builder.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::builder::{ArrayBuilder, BufferBuilder};
+use crate::builder::ArrayBuilder;
 use crate::{Array, ArrayRef, GenericListArray, OffsetSizeTrait};
 use arrow_buffer::NullBufferBuilder;
 use arrow_buffer::{Buffer, OffsetBuffer};
@@ -86,7 +86,7 @@ use std::sync::Arc;
 /// [`LargeListArray`]: crate::array::LargeListArray
 #[derive(Debug)]
 pub struct GenericListBuilder<OffsetSize: OffsetSizeTrait, T: ArrayBuilder> {
-    offsets_builder: BufferBuilder<OffsetSize>,
+    offsets_builder: Vec<OffsetSize>,
     null_buffer_builder: NullBufferBuilder,
     values_builder: T,
     field: Option<FieldRef>,
@@ -108,8 +108,8 @@ impl<OffsetSize: OffsetSizeTrait, T: ArrayBuilder> GenericListBuilder<OffsetSize
     /// Creates a new [`GenericListBuilder`] from a given values array builder
     /// `capacity` is the number of items to pre-allocate space for in this builder
     pub fn with_capacity(values_builder: T, capacity: usize) -> Self {
-        let mut offsets_builder = BufferBuilder::<OffsetSize>::new(capacity + 1);
-        offsets_builder.append(OffsetSize::zero());
+        let mut offsets_builder = Vec::with_capacity(capacity + 1);
+        offsets_builder.push(OffsetSize::zero());
         Self {
             offsets_builder,
             null_buffer_builder: NullBufferBuilder::new(capacity),
@@ -192,7 +192,7 @@ where
     /// Panics if the length of [`Self::values`] exceeds `OffsetSize::MAX`
     #[inline]
     pub fn append(&mut self, is_valid: bool) {
-        self.offsets_builder.append(self.next_offset());
+        self.offsets_builder.push(self.next_offset());
         self.null_buffer_builder.append(is_valid);
     }
 
@@ -266,7 +266,7 @@ where
     /// See [`Self::append_value`] for an example use.
     #[inline]
     pub fn append_null(&mut self) {
-        self.offsets_builder.append(self.next_offset());
+        self.offsets_builder.push(self.next_offset());
         self.null_buffer_builder.append_null();
     }
 
@@ -274,7 +274,8 @@ where
     #[inline]
     pub fn append_nulls(&mut self, n: usize) {
         let next_offset = self.next_offset();
-        self.offsets_builder.append_n(n, next_offset);
+        self.offsets_builder
+            .extend(std::iter::repeat_n(next_offset, n));
         self.null_buffer_builder.append_n_nulls(n);
     }
 
@@ -298,10 +299,10 @@ where
         let values = self.values_builder.finish();
         let nulls = self.null_buffer_builder.finish();
 
-        let offsets = self.offsets_builder.finish();
+        let offsets = Buffer::from_vec(std::mem::take(&mut self.offsets_builder));
         // Safety: Safe by construction
         let offsets = unsafe { OffsetBuffer::new_unchecked(offsets.into()) };
-        self.offsets_builder.append(OffsetSize::zero());
+        self.offsets_builder.push(OffsetSize::zero());
 
         let field = match &self.field {
             Some(f) => f.clone(),
diff --git a/arrow-array/src/builder/generic_list_view_builder.rs b/arrow-array/src/builder/generic_list_view_builder.rs
index 5aaf9efefe24..23204fca31b8 100644
--- a/arrow-array/src/builder/generic_list_view_builder.rs
+++ b/arrow-array/src/builder/generic_list_view_builder.rs
@@ -17,7 +17,7 @@
 
 use crate::builder::ArrayBuilder;
 use crate::{ArrayRef, GenericListViewArray, OffsetSizeTrait};
-use arrow_buffer::{Buffer, BufferBuilder, NullBufferBuilder, ScalarBuffer};
+use arrow_buffer::{Buffer, NullBufferBuilder, ScalarBuffer};
 use arrow_schema::{Field, FieldRef};
 use std::any::Any;
 use std::sync::Arc;
@@ -25,8 +25,8 @@ use std::sync::Arc;
 /// Builder for [`GenericListViewArray`]
 #[derive(Debug)]
 pub struct GenericListViewBuilder<OffsetSize: OffsetSizeTrait, T: ArrayBuilder> {
-    offsets_builder: BufferBuilder<OffsetSize>,
-    sizes_builder: BufferBuilder<OffsetSize>,
+    offsets_builder: Vec<OffsetSize>,
+    sizes_builder: Vec<OffsetSize>,
     null_buffer_builder: NullBufferBuilder,
     values_builder: T,
     field: Option<FieldRef>,
@@ -83,8 +83,8 @@ impl<OffsetSize: OffsetSizeTrait, T: ArrayBuilder> GenericListViewBuilder<Offset
     /// Creates a new [`GenericListViewBuilder`] from a given values array builder
     /// `capacity` is the number of items to pre-allocate space for in this builder
     pub fn with_capacity(values_builder: T, capacity: usize) -> Self {
-        let offsets_builder = BufferBuilder::<OffsetSize>::new(capacity);
-        let sizes_builder = BufferBuilder::<OffsetSize>::new(capacity);
+        let offsets_builder = Vec::with_capacity(capacity);
+        let sizes_builder = Vec::with_capacity(capacity);
         Self {
             offsets_builder,
             null_buffer_builder: NullBufferBuilder::new(capacity),
@@ -132,8 +132,8 @@ where
     /// Panics if the length of [`Self::values`] exceeds `OffsetSize::MAX`
     #[inline]
     pub fn append(&mut self, is_valid: bool) {
-        self.offsets_builder.append(self.current_offset);
-        self.sizes_builder.append(
+        self.offsets_builder.push(self.current_offset);
+        self.sizes_builder.push(
             OffsetSize::from_usize(
                 self.values_builder.len() - self.current_offset.to_usize().unwrap(),
             )
@@ -158,9 +158,8 @@ where
     /// See [`Self::append_value`] for an example use.
     #[inline]
     pub fn append_null(&mut self) {
-        self.offsets_builder.append(self.current_offset);
-        self.sizes_builder
-            .append(OffsetSize::from_usize(0).unwrap());
+        self.offsets_builder.push(self.current_offset);
+        self.sizes_builder.push(OffsetSize::from_usize(0).unwrap());
         self.null_buffer_builder.append_null();
     }
 
@@ -183,12 +182,12 @@ where
     pub fn finish(&mut self) -> GenericListViewArray<OffsetSize> {
         let values = self.values_builder.finish();
         let nulls = self.null_buffer_builder.finish();
-        let offsets = self.offsets_builder.finish();
+        let offsets = Buffer::from_vec(std::mem::take(&mut self.offsets_builder));
         self.current_offset = OffsetSize::zero();
 
         // Safety: Safe by construction
         let offsets = ScalarBuffer::from(offsets);
-        let sizes = self.sizes_builder.finish();
+        let sizes = Buffer::from_vec(std::mem::take(&mut self.sizes_builder));
         let sizes = ScalarBuffer::from(sizes);
         let field = match &self.field {
             Some(f) => f.clone(),
diff --git a/arrow-array/src/builder/map_builder.rs b/arrow-array/src/builder/map_builder.rs
index 012a454e76c9..a9895eabed32 100644
--- a/arrow-array/src/builder/map_builder.rs
+++ b/arrow-array/src/builder/map_builder.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::builder::{ArrayBuilder, BufferBuilder};
+use crate::builder::ArrayBuilder;
 use crate::{Array, ArrayRef, MapArray, StructArray};
 use arrow_buffer::Buffer;
 use arrow_buffer::{NullBuffer, NullBufferBuilder};
@@ -56,7 +56,7 @@ use std::sync::Arc;
 /// ```
 #[derive(Debug)]
 pub struct MapBuilder<K: ArrayBuilder, V: ArrayBuilder> {
-    offsets_builder: BufferBuilder<i32>,
+    offsets_builder: Vec<i32>,
     null_buffer_builder: NullBufferBuilder,
     field_names: MapFieldNames,
     key_builder: K,
@@ -100,8 +100,8 @@ impl<K: ArrayBuilder, V: ArrayBuilder> MapBuilder<K, V> {
         value_builder: V,
         capacity: usize,
     ) -> Self {
-        let mut offsets_builder = BufferBuilder::<i32>::new(capacity + 1);
-        offsets_builder.append(0);
+        let mut offsets_builder = Vec::with_capacity(capacity + 1);
+        offsets_builder.push(0);
         Self {
             offsets_builder,
             null_buffer_builder: NullBufferBuilder::new(capacity),
@@ -166,7 +166,7 @@ impl<K: ArrayBuilder, V: ArrayBuilder> MapBuilder<K, V> {
                 self.value_builder.len()
             )));
         }
-        self.offsets_builder.append(self.key_builder.len() as i32);
+        self.offsets_builder.push(self.key_builder.len() as i32);
         self.null_buffer_builder.append(is_valid);
         Ok(())
     }
@@ -177,8 +177,8 @@ impl<K: ArrayBuilder, V: ArrayBuilder> MapBuilder<K, V> {
         // Build the keys
         let keys_arr = self.key_builder.finish();
         let values_arr = self.value_builder.finish();
-        let offset_buffer = self.offsets_builder.finish();
-        self.offsets_builder.append(0);
+        let offset_buffer = Buffer::from_vec(std::mem::take(&mut self.offsets_builder));
+        self.offsets_builder.push(0);
         let null_bit_buffer = self.null_buffer_builder.finish();
 
         self.finish_helper(keys_arr, values_arr, offset_buffer, null_bit_buffer, len)
diff --git a/arrow-array/src/builder/primitive_builder.rs b/arrow-array/src/builder/primitive_builder.rs
index 7aca730ce192..049cef241c83 100644
--- a/arrow-array/src/builder/primitive_builder.rs
+++ b/arrow-array/src/builder/primitive_builder.rs
@@ -15,11 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::builder::{ArrayBuilder, BufferBuilder};
+use crate::builder::ArrayBuilder;
 use crate::types::*;
 use crate::{Array, ArrayRef, PrimitiveArray};
-use arrow_buffer::NullBufferBuilder;
-use arrow_buffer::{Buffer, MutableBuffer};
+use arrow_buffer::{Buffer, MutableBuffer, NullBufferBuilder, ScalarBuffer};
 use arrow_data::ArrayData;
 use arrow_schema::{ArrowError, DataType};
 use std::any::Any;
@@ -99,7 +98,7 @@ pub type Decimal256Builder = PrimitiveBuilder<Decimal256Type>;
 /// Builder for [`PrimitiveArray`]
 #[derive(Debug)]
 pub struct PrimitiveBuilder<T: ArrowPrimitiveType> {
-    values_builder: BufferBuilder<T::Native>,
+    values_builder: Vec<T::Native>,
     null_buffer_builder: NullBufferBuilder,
     data_type: DataType,
 }
@@ -151,7 +150,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
     /// Creates a new primitive array builder with capacity no of items
     pub fn with_capacity(capacity: usize) -> Self {
         Self {
-            values_builder: BufferBuilder::<T::Native>::new(capacity),
+            values_builder: Vec::with_capacity(capacity),
             null_buffer_builder: NullBufferBuilder::new(capacity),
             data_type: T::DATA_TYPE,
         }
@@ -162,7 +161,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
         values_buffer: MutableBuffer,
         null_buffer: Option<MutableBuffer>,
     ) -> Self {
-        let values_builder = BufferBuilder::<T::Native>::new_from_buffer(values_buffer);
+        let values_builder: Vec<T::Native> = ScalarBuffer::<T::Native>::from(values_buffer).into();
 
         let null_buffer_builder = null_buffer
             .map(|buffer| NullBufferBuilder::new_from_buffer(buffer, values_builder.len()))
@@ -204,28 +203,29 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
     #[inline]
     pub fn append_value(&mut self, v: T::Native) {
         self.null_buffer_builder.append_non_null();
-        self.values_builder.append(v);
+        self.values_builder.push(v);
     }
 
     /// Appends a value of type `T` into the builder `n` times
     #[inline]
     pub fn append_value_n(&mut self, v: T::Native, n: usize) {
         self.null_buffer_builder.append_n_non_nulls(n);
-        self.values_builder.append_n(n, v);
+        self.values_builder.extend(std::iter::repeat_n(v, n));
     }
 
     /// Appends a null slot into the builder
     #[inline]
     pub fn append_null(&mut self) {
         self.null_buffer_builder.append_null();
-        self.values_builder.advance(1);
+        self.values_builder.push(T::Native::default());
     }
 
     /// Appends `n` no. of null's into the builder
     #[inline]
     pub fn append_nulls(&mut self, n: usize) {
         self.null_buffer_builder.append_n_nulls(n);
-        self.values_builder.advance(n);
+        self.values_builder
+            .extend(std::iter::repeat_n(T::Native::default(), n));
     }
 
     /// Appends an `Option<T>` into the builder
@@ -241,7 +241,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
     #[inline]
     pub fn append_slice(&mut self, v: &[T::Native]) {
         self.null_buffer_builder.append_n_non_nulls(v.len());
-        self.values_builder.append_slice(v);
+        self.values_builder.extend_from_slice(v);
     }
 
     /// Appends values from a slice of type `T` and a validity boolean slice
@@ -257,7 +257,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
             "Value and validity lengths must be equal"
         );
         self.null_buffer_builder.append_slice(is_valid);
-        self.values_builder.append_slice(values);
+        self.values_builder.extend_from_slice(values);
     }
 
     /// Appends array values and null to this builder as is
@@ -274,7 +274,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
             "array data type mismatch"
         );
 
-        self.values_builder.append_slice(array.values());
+        self.values_builder.extend_from_slice(array.values());
         if let Some(null_buffer) = array.nulls() {
             self.null_buffer_builder.append_buffer(null_buffer);
         } else {
@@ -296,7 +296,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
             .expect("append_trusted_len_iter requires an upper bound");
 
         self.null_buffer_builder.append_n_non_nulls(len);
-        self.values_builder.append_trusted_len_iter(iter);
+        self.values_builder.extend(iter);
     }
 
     /// Builds the [`PrimitiveArray`] and reset this builder.
@@ -305,7 +305,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
         let nulls = self.null_buffer_builder.finish();
         let builder = ArrayData::builder(self.data_type.clone())
             .len(len)
-            .add_buffer(self.values_builder.finish())
+            .add_buffer(std::mem::take(&mut self.values_builder).into())
             .nulls(nulls);
 
         let array_data = unsafe { builder.build_unchecked() };
@@ -333,7 +333,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
 
     /// Returns the current values buffer as a mutable slice
     pub fn values_slice_mut(&mut self) -> &mut [T::Native] {
-        self.values_builder.as_slice_mut()
+        self.values_builder.as_mut_slice()
     }
 
     /// Returns the current null buffer as a slice
@@ -349,7 +349,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
     /// Returns the current values buffer and null buffer as a slice
     pub fn slices_mut(&mut self) -> (&mut [T::Native], Option<&mut [u8]>) {
         (
-            self.values_builder.as_slice_mut(),
+            self.values_builder.as_mut_slice(),
             self.null_buffer_builder.as_slice_mut(),
         )
     }
diff --git a/arrow-select/src/concat.rs b/arrow-select/src/concat.rs
index 6636988305c5..bd93650055bc 100644
--- a/arrow-select/src/concat.rs
+++ b/arrow-select/src/concat.rs
@@ -1189,11 +1189,9 @@ mod tests {
         // 3 * 3   = 9
         // ------------+
         // 909
-        // closest 64 byte aligned cap = 960
 
         let arr = concat(&[&a, &b, &c]).unwrap();
-        // this would have been 1280 if we did not precompute the value lengths.
-        assert_eq!(arr.to_data().buffers()[1].capacity(), 960);
+        assert_eq!(arr.to_data().buffers()[1].capacity(), 909);
     }
 
     #[test]
@@ -1328,12 +1326,12 @@ mod tests {
         let a = concat(&[&a, &b]).unwrap();
         let data = a.to_data();
         assert_eq!(data.buffers()[0].len(), 440);
-        assert_eq!(data.buffers()[0].capacity(), 448); // Nearest multiple of 64
+        assert_eq!(data.buffers()[0].capacity(), 440);
 
         let a = concat(&[&a.slice(10, 20), &b]).unwrap();
         let data = a.to_data();
         assert_eq!(data.buffers()[0].len(), 120);
-        assert_eq!(data.buffers()[0].capacity(), 128); // Nearest multiple of 64
+        assert_eq!(data.buffers()[0].capacity(), 120);
 
         let a = StringArray::from_iter_values(std::iter::repeat_n("foo", 100));
         let b = StringArray::from(vec!["bingo", "bongo", "lorem", ""]);
@@ -1342,21 +1340,21 @@ mod tests {
         let data = a.to_data();
         // (100 + 4 + 1) * size_of<i32>()
         assert_eq!(data.buffers()[0].len(), 420);
-        assert_eq!(data.buffers()[0].capacity(), 448); // Nearest multiple of 64
+        assert_eq!(data.buffers()[0].capacity(), 420);
 
         // len("foo") * 100 + len("bingo") + len("bongo") + len("lorem")
         assert_eq!(data.buffers()[1].len(), 315);
-        assert_eq!(data.buffers()[1].capacity(), 320); // Nearest multiple of 64
+        assert_eq!(data.buffers()[1].capacity(), 315);
 
         let a = concat(&[&a.slice(10, 40), &b]).unwrap();
         let data = a.to_data();
         // (40 + 4 + 5) * size_of<i32>()
         assert_eq!(data.buffers()[0].len(), 180);
-        assert_eq!(data.buffers()[0].capacity(), 192); // Nearest multiple of 64
+        assert_eq!(data.buffers()[0].capacity(), 180);
 
         // len("foo") * 40 + len("bingo") + len("bongo") + len("lorem")
         assert_eq!(data.buffers()[1].len(), 135);
-        assert_eq!(data.buffers()[1].capacity(), 192); // Nearest multiple of 64
+        assert_eq!(data.buffers()[1].capacity(), 135);
 
         let a = LargeBinaryArray::from_iter_values(std::iter::repeat_n(b"foo", 100));
         let b = LargeBinaryArray::from_iter_values(std::iter::repeat_n(b"cupcakes", 10));
@@ -1365,21 +1363,21 @@ mod tests {
         let data = a.to_data();
         // (100 + 10 + 1) * size_of<i64>()
         assert_eq!(data.buffers()[0].len(), 888);
-        assert_eq!(data.buffers()[0].capacity(), 896); // Nearest multiple of 64
+        assert_eq!(data.buffers()[0].capacity(), 888);
 
         // len("foo") * 100 + len("cupcakes") * 10
         assert_eq!(data.buffers()[1].len(), 380);
-        assert_eq!(data.buffers()[1].capacity(), 384); // Nearest multiple of 64
+        assert_eq!(data.buffers()[1].capacity(), 380);
 
         let a = concat(&[&a.slice(10, 40), &b]).unwrap();
         let data = a.to_data();
         // (40 + 10 + 1) * size_of<i64>()
         assert_eq!(data.buffers()[0].len(), 408);
-        assert_eq!(data.buffers()[0].capacity(), 448); // Nearest multiple of 64
+        assert_eq!(data.buffers()[0].capacity(), 408);
 
         // len("foo") * 40 + len("cupcakes") * 10
         assert_eq!(data.buffers()[1].len(), 200);
-        assert_eq!(data.buffers()[1].capacity(), 256); // Nearest multiple of 64
+        assert_eq!(data.buffers()[1].capacity(), 200);
     }
 
     #[test]