diff --git a/quic/api/test/QuicPacketSchedulerTest.cpp b/quic/api/test/QuicPacketSchedulerTest.cpp
index 43626cf78..f34c71e90 100644
--- a/quic/api/test/QuicPacketSchedulerTest.cpp
+++ b/quic/api/test/QuicPacketSchedulerTest.cpp
@@ -368,7 +368,7 @@ TEST_F(QuicPacketSchedulerTest, WriteOnlyOutstandingPacketsTest) {
       "The sun is in the sky.");
   MaxStreamsFrame maxStreamFrame(999, true);
   PingFrame pingFrame;
-  IntervalSet<PacketNum> ackBlocks;
+  WriteAckFrame::AckBlocks ackBlocks;
   ackBlocks.insert(10, 100);
   ackBlocks.insert(200, 1000);
   AckFrameMetaData ackMeta(ackBlocks, 0us, kDefaultAckDelayExponent);
diff --git a/quic/client/test/QuicClientTransportTest.cpp b/quic/client/test/QuicClientTransportTest.cpp
index d5eb872e6..0b727a50d 100644
--- a/quic/client/test/QuicClientTransportTest.cpp
+++ b/quic/client/test/QuicClientTransportTest.cpp
@@ -1592,7 +1592,7 @@ class QuicClientTransportTest : public Test {
     return codecResult.regularPacket();
   }
 
-  void verifyShortPackets(IntervalSet<PacketNum>& sentPackets) {
+  void verifyShortPackets(WriteAckFrame::AckBlocks& sentPackets) {
     AckStates ackStates;
     for (auto& write : socketWrites) {
       auto packetQueue = bufToQueue(write->clone());
@@ -3237,7 +3237,7 @@ TEST_F(QuicClientTransportAfterStartTest, CloseConnectionWithStreamPending) {
   // ack all the packets
   ASSERT_FALSE(client->getConn().outstandingPackets.empty());
 
-  IntervalSet<quic::PacketNum> acks;
+  WriteAckFrame::AckBlocks acks;
   auto start = getFirstOutstandingPacket(
                    client->getNonConstConn(), PacketNumberSpace::AppData)
                    ->packet.header.getPacketSequenceNum();
@@ -3312,7 +3312,7 @@ TEST_F(QuicClientTransportAfterStartTest, CloseConnectionWithNoStreamPending) {
   // ack all the packets
   ASSERT_FALSE(client->getConn().outstandingPackets.empty());
 
-  IntervalSet<quic::PacketNum> acks;
+  WriteAckFrame::AckBlocks acks;
   auto start = getFirstOutstandingPacket(
                    client->getNonConstConn(), PacketNumberSpace::AppData)
                    ->packet.header.getPacketSequenceNum();
@@ -3444,7 +3444,7 @@ TEST_F(QuicClientTransportAfterStartTest, RecvAckOfCryptoStream) {
   auto& headerCipher = getInitialHeaderCipher();
   // initial
   {
-    IntervalSet<quic::PacketNum> acks;
+    WriteAckFrame::AckBlocks acks;
     auto start = getFirstOutstandingPacket(
                      client->getNonConstConn(), PacketNumberSpace::Initial)
                      ->packet.header.getPacketSequenceNum();
@@ -3463,7 +3463,7 @@ TEST_F(QuicClientTransportAfterStartTest, RecvAckOfCryptoStream) {
   }
   // handshake
   {
-    IntervalSet<quic::PacketNum> acks;
+    WriteAckFrame::AckBlocks acks;
     auto start = getFirstOutstandingPacket(
                      client->getNonConstConn(), PacketNumberSpace::Handshake)
                      ->packet.header.getPacketSequenceNum();
@@ -3501,7 +3501,7 @@ TEST_F(QuicClientTransportAfterStartTest, RecvOneRttAck) {
   client->writeChain(streamId, expected->clone(), true, false);
   loopForWrites();
 
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
   verifyShortPackets(sentPackets);
 
   // Write an AckFrame back to client:
@@ -3723,7 +3723,7 @@ TEST_F(QuicClientTransportAfterStartTest, IdleTimerNotResetOnWritingOldData) {
 
 TEST_F(QuicClientTransportAfterStartTest, IdleTimerResetNoOutstandingPackets) {
   // This will clear out all the outstanding packets
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
   for (auto& packet : client->getNonConstConn().outstandingPackets) {
     auto packetNum = packet.packet.header.getPacketSequenceNum();
     sentPackets.insert(packetNum);
@@ -3976,7 +3976,7 @@ TEST_F(
 
   client->setReadCallback(streamId, nullptr);
 
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
   auto writeData = IOBuf::copyBuffer("some data");
   client->writeChain(streamId, writeData->clone(), true, false);
   loopForWrites();
@@ -4000,7 +4000,7 @@ TEST_F(QuicClientTransportAfterStartTest, StreamClosedIfReadCallbackNull) {
   auto streamId =
       client->createBidirectionalStream(false /* replaySafe */).value();
 
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
   auto writeData = IOBuf::copyBuffer("some data");
   client->writeChain(streamId, writeData->clone(), true, false);
   loopForWrites();
@@ -4033,7 +4033,7 @@ TEST_F(QuicClientTransportAfterStartTest, StreamClosedIfReadCallbackNull) {
 }
 
 TEST_F(QuicClientTransportAfterStartTest, ReceiveAckInvokesDeliveryCallback) {
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
   auto streamId =
       client->createBidirectionalStream(false /* replaySafe */).value();
   client->registerDeliveryCallback(streamId, 0, &deliveryCallback);
@@ -4057,7 +4057,7 @@ TEST_F(QuicClientTransportAfterStartTest, ReceiveAckInvokesDeliveryCallback) {
 }
 
 TEST_F(QuicClientTransportAfterStartTest, InvokesDeliveryCallbackFinOnly) {
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
   auto streamId =
       client->createBidirectionalStream(false /* replaySafe */).value();
 
@@ -4083,7 +4083,7 @@ TEST_F(QuicClientTransportAfterStartTest, InvokesDeliveryCallbackFinOnly) {
 TEST_F(
     QuicClientTransportAfterStartTest,
     RegisterDeliveryCallbackForAlreadyDeliveredOffset) {
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
 
   auto streamId =
       client->createBidirectionalStream(false /* replaySafe */).value();
@@ -4111,7 +4111,7 @@ TEST_F(
 }
 
 TEST_F(QuicClientTransportAfterStartTest, DeliveryCallbackFromWriteChain) {
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
   auto streamId =
       client->createBidirectionalStream(false /* replaySafe */).value();
 
@@ -4334,7 +4334,7 @@ TEST_F(QuicClientTransportVersionAndRetryTest, UnencryptedStreamData) {
 }
 
 TEST_F(QuicClientTransportVersionAndRetryTest, UnencryptedAckData) {
-  IntervalSet<PacketNum> acks = {{1, 2}};
+  WriteAckFrame::AckBlocks acks = {{1, 2}};
   auto expected = IOBuf::copyBuffer("hello");
   PacketNum nextPacketNum = initialPacketNum++;
   LongHeader header(
@@ -4402,7 +4402,7 @@ TEST_F(QuicClientTransportVersionAndRetryTest, FrameNotAllowed) {
 }
 
 TEST_F(QuicClientTransportAfterStartTest, SendReset) {
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
   StreamId streamId = client->createBidirectionalStream().value();
   client->setReadCallback(streamId, &readCb);
   client->registerDeliveryCallback(streamId, 100, &deliveryCallback);
@@ -4503,7 +4503,7 @@ TEST_F(QuicClientTransportAfterStartTest, LossAfterResetStream) {
 }
 
 TEST_F(QuicClientTransportAfterStartTest, SendResetAfterEom) {
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
   StreamId streamId = client->createBidirectionalStream().value();
   client->setReadCallback(streamId, &readCb);
   client->registerDeliveryCallback(streamId, 100, &deliveryCallback);
@@ -4533,7 +4533,7 @@ TEST_F(QuicClientTransportAfterStartTest, SendResetAfterEom) {
 }
 
 TEST_F(QuicClientTransportAfterStartTest, HalfClosedLocalToClosed) {
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
   StreamId streamId = client->createBidirectionalStream().value();
   client->setReadCallback(streamId, &readCb);
   auto data = test::buildRandomInputData(10);
@@ -4581,7 +4581,7 @@ TEST_F(QuicClientTransportAfterStartTest, HalfClosedLocalToClosed) {
 }
 
 TEST_F(QuicClientTransportAfterStartTest, SendResetSyncOnAck) {
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
   StreamId streamId = client->createBidirectionalStream().value();
   StreamId streamId2 = client->createBidirectionalStream().value();
 
@@ -4663,7 +4663,7 @@ TEST_F(QuicClientTransportAfterStartTest, HalfClosedRemoteToClosed) {
   EXPECT_EQ(readCbs.count(streamId), 1);
   EXPECT_EQ(conn.streamManager->readableStreams().count(streamId), 0);
 
-  IntervalSet<PacketNum> sentPackets;
+  WriteAckFrame::AckBlocks sentPackets;
   client->writeChain(streamId, data->clone(), true, false, &deliveryCallback);
   loopForWrites();
 
diff --git a/quic/codec/QuicWriteCodec.cpp b/quic/codec/QuicWriteCodec.cpp
index a3b862b00..a9e61a8d4 100644
--- a/quic/codec/QuicWriteCodec.cpp
+++ b/quic/codec/QuicWriteCodec.cpp
@@ -196,12 +196,12 @@ writeCryptoFrame(uint64_t offsetIn, Buf data, PacketBuilderInterface& builder) {
 }
 
 size_t fillFrameWithAckBlocks(
-    const IntervalSet<PacketNum>& ackBlocks,
+    const WriteAckFrame::AckBlocks& ackBlocks,
     WriteAckFrame& ackFrame,
     uint64_t bytesLimit);
 
 size_t fillFrameWithAckBlocks(
-    const IntervalSet<PacketNum>& ackBlocks,
+    const WriteAckFrame::AckBlocks& ackBlocks,
     WriteAckFrame& ackFrame,
     uint64_t bytesLimit) {
   PacketNum currentSeqNum = ackBlocks.crbegin()->start;
diff --git a/quic/codec/QuicWriteCodec.h b/quic/codec/QuicWriteCodec.h
index 3cd6c7efd..401d36a41 100644
--- a/quic/codec/QuicWriteCodec.h
+++ b/quic/codec/QuicWriteCodec.h
@@ -17,14 +17,14 @@ namespace quic {
 
 struct AckFrameMetaData {
   // Ack blocks. There must be at least 1 ACK block to send.
-  const IntervalSet<PacketNum>& ackBlocks;
+  const WriteAckFrame::AckBlocks& ackBlocks;
   // Delay in sending ack from time that packet was received.
   std::chrono::microseconds ackDelay;
   // The ack delay exponent to use.
   uint8_t ackDelayExponent;
 
   AckFrameMetaData(
-      const IntervalSet<PacketNum>& acksIn,
+      const WriteAckFrame::AckBlocks& acksIn,
       std::chrono::microseconds ackDelayIn,
       uint8_t ackDelayExponentIn)
       : ackBlocks(acksIn),
diff --git a/quic/codec/Types.h b/quic/codec/Types.h
index 1d39423c4..9ed356c3b 100644
--- a/quic/codec/Types.h
+++ b/quic/codec/Types.h
@@ -46,6 +46,7 @@ enum class PacketNumberSpace : uint8_t {
 
 constexpr uint8_t kHeaderFormMask = 0x80;
 constexpr auto kMaxPacketNumEncodingSize = 4;
+constexpr auto kNumInitialAckBlocksPerFrame = 32;
 
 struct PaddingFrame {
   bool operator==(const PaddingFrame& /*rhs*/) const {
@@ -98,7 +99,7 @@ struct ReadAckFrame {
   std::chrono::microseconds ackDelay{0us};
   // Should have at least 1 block.
   // These are ordered in descending order by start packet.
-  using Vec = SmallVec<AckBlock, 32, uint16_t>;
+  using Vec = SmallVec<AckBlock, kNumInitialAckBlocksPerFrame, uint16_t>;
   Vec ackBlocks;
 
   bool operator==(const ReadAckFrame& /*rhs*/) const {
@@ -108,7 +109,10 @@ struct ReadAckFrame {
 };
 
 struct WriteAckFrame {
-  IntervalSet<PacketNum> ackBlocks;
+  template <class T>
+  using IntervalSetVec = SmallVec<T, kNumInitialAckBlocksPerFrame, uint16_t>;
+  using AckBlocks = IntervalSet<PacketNum, 1, IntervalSetVec>;
+  AckBlocks ackBlocks;
   // Delay in sending ack from time that packet was received.
   std::chrono::microseconds ackDelay{0us};
 
diff --git a/quic/codec/test/QuicPacketRebuilderTest.cpp b/quic/codec/test/QuicPacketRebuilderTest.cpp
index 3c6f0196d..18f8c04df 100644
--- a/quic/codec/test/QuicPacketRebuilderTest.cpp
+++ b/quic/codec/test/QuicPacketRebuilderTest.cpp
@@ -63,7 +63,7 @@ TEST_F(QuicPacketRebuilderTest, RebuildPacket) {
       "The sun is in the sky.",
       FrameType::ACK);
   MaxStreamsFrame maxStreamsFrame(4321, true);
-  IntervalSet<PacketNum> ackBlocks;
+  WriteAckFrame::AckBlocks ackBlocks;
   ackBlocks.insert(10, 100);
   ackBlocks.insert(200, 1000);
   AckFrameMetaData ackMeta(ackBlocks, 0us, kDefaultAckDelayExponent);
@@ -369,7 +369,7 @@ TEST_F(QuicPacketRebuilderTest, CannotRebuild) {
       "The sun is in the sky.",
       FrameType::ACK);
   StreamsBlockedFrame maxStreamIdFrame(0x1024, true);
-  IntervalSet<PacketNum> ackBlocks;
+  WriteAckFrame::AckBlocks ackBlocks;
   ackBlocks.insert(10, 100);
   ackBlocks.insert(200, 1000);
   AckFrameMetaData ackMeta(ackBlocks, 0us, kDefaultAckDelayExponent);
diff --git a/quic/codec/test/QuicWriteCodecTest.cpp b/quic/codec/test/QuicWriteCodecTest.cpp
index 017dd2cb6..a41ddd33d 100644
--- a/quic/codec/test/QuicWriteCodecTest.cpp
+++ b/quic/codec/test/QuicWriteCodecTest.cpp
@@ -571,7 +571,7 @@ TEST_F(QuicWriteCodecTest, AckFrameGapExceedsRepresentation) {
   PacketNum max = std::numeric_limits<uint64_t>::max();
   // Can't use max directly, because it will exceed interval set's
   // representation.
-  IntervalSet<PacketNum> ackBlocks = {{max - 10, max - 10}, {1, 1}};
+  WriteAckFrame::AckBlocks ackBlocks = {{max - 10, max - 10}, {1, 1}};
   EXPECT_THROW(
       writeAckFrame(
           AckFrameMetaData(ackBlocks, 0us, kDefaultAckDelayExponent),
@@ -589,7 +589,7 @@ TEST_F(QuicWriteCodecTest, AckFrameVeryLargeAckRange) {
   // There is 1 gap => each represented by 8 bytes => 8 bytes
   // total 11 bytes
   PacketNum largest = (uint64_t)1 << 55;
-  IntervalSet<PacketNum> ackBlocks = {{1, largest}};
+  WriteAckFrame::AckBlocks ackBlocks = {{1, largest}};
   AckFrameMetaData ackMetadata(ackBlocks, 0us, kDefaultAckDelayExponent);
 
   auto ackFrameWriteResult = *writeAckFrame(ackMetadata, pktBuilder);
@@ -617,7 +617,7 @@ TEST_F(QuicWriteCodecTest, AckFrameNotEnoughForAnything) {
   // There are 2 gaps => each represented by 2 bytes => 4 bytes
   // 1 byte for first ack block length, then 2 bytes for each pair => 5 bytes
   // total 15 bytes
-  IntervalSet<PacketNum> ackBlocks = {{1000, 1000}, {500, 700}, {100, 200}};
+  WriteAckFrame::AckBlocks ackBlocks = {{1000, 1000}, {500, 700}, {100, 200}};
   // 4 btyes are just not enough for anything
   AckFrameMetaData ackMetadata(ackBlocks, 555us, kDefaultAckDelayExponent);
 
@@ -630,7 +630,7 @@ TEST_F(QuicWriteCodecTest, WriteSimpleAckFrame) {
   MockQuicPacketBuilder pktBuilder;
   setupCommonExpects(pktBuilder);
   auto ackDelay = 111us;
-  IntervalSet<PacketNum> ackBlocks = {{501, 1000}, {101, 400}};
+  WriteAckFrame::AckBlocks ackBlocks = {{501, 1000}, {101, 400}};
   AckFrameMetaData meta(ackBlocks, ackDelay, kDefaultAckDelayExponent);
 
   // 1 type byte,
@@ -675,7 +675,7 @@ TEST_F(QuicWriteCodecTest, WriteAckFrameWillSaveAckDelay) {
   MockQuicPacketBuilder pktBuilder;
   setupCommonExpects(pktBuilder);
   auto ackDelay = 111us;
-  IntervalSet<PacketNum> ackBlocks = {{501, 1000}, {101, 400}};
+  WriteAckFrame::AckBlocks ackBlocks = {{501, 1000}, {101, 400}};
   AckFrameMetaData meta(ackBlocks, ackDelay, kDefaultAckDelayExponent);
 
   writeAckFrame(meta, pktBuilder);
@@ -703,7 +703,7 @@ TEST_F(QuicWriteCodecTest, VerifyNumAckBlocksSizeAccounted) {
   auto gap = 2;
   PacketNum largest = 1000;
   PacketNum currentEnd = largest - blockLength - gap;
-  IntervalSet<PacketNum> ackBlocks;
+  WriteAckFrame::AckBlocks ackBlocks;
   for (int i = 0; i < 64; i++) {
     CHECK_GE(currentEnd, blockLength);
     ackBlocks.insert({currentEnd - blockLength, currentEnd});
@@ -730,7 +730,7 @@ TEST_F(QuicWriteCodecTest, WriteWithDifferentAckDelayExponent) {
   MockQuicPacketBuilder pktBuilder;
   setupCommonExpects(pktBuilder);
 
-  IntervalSet<PacketNum> ackBlocks{{1000, 1000}};
+  WriteAckFrame::AckBlocks ackBlocks{{1000, 1000}};
   uint8_t ackDelayExponent = 6;
   AckFrameMetaData ackMetadata(ackBlocks, 1240us, ackDelayExponent);
 
@@ -753,7 +753,7 @@ TEST_F(QuicWriteCodecTest, WriteExponentInLongHeaderPacket) {
   MockQuicPacketBuilder pktBuilder;
   setupCommonExpects(pktBuilder);
 
-  IntervalSet<PacketNum> ackBlocks{{1000, 1000}};
+  WriteAckFrame::AckBlocks ackBlocks{{1000, 1000}};
   uint8_t ackDelayExponent = 6;
   AckFrameMetaData ackMetadata(ackBlocks, 1240us, ackDelayExponent);
 
@@ -783,7 +783,7 @@ TEST_F(QuicWriteCodecTest, OnlyAckLargestPacket) {
   // 1 byte for ack block count
   // 1 byte for first ack block length
   // total 7 bytes
-  IntervalSet<PacketNum> ackBlocks{{1000, 1000}};
+  WriteAckFrame::AckBlocks ackBlocks{{1000, 1000}};
   AckFrameMetaData ackMetadata(ackBlocks, 555us, kDefaultAckDelayExponent);
 
   // No AckBlock is added to the metadata. There will still be one block
@@ -827,7 +827,7 @@ TEST_F(QuicWriteCodecTest, WriteSomeAckBlocks) {
   // 1 byte for first ack block length
   // each additional ack block 1 byte gap + 1 byte length => 2 bytes
   // total 7 bytes
-  IntervalSet<PacketNum> testAckBlocks;
+  WriteAckFrame::AckBlocks testAckBlocks;
   PacketNum currentEnd = 1000;
   auto blockLength = 5;
   auto gap = 10;
@@ -871,7 +871,7 @@ TEST_F(QuicWriteCodecTest, NoSpaceForAckBlockSection) {
   // 2 bytes for largest acked, 2 bytes for ack delay => 4 bytes
   // 1 byte for num ack blocks
   // 1 byte for first ack block length
-  IntervalSet<PacketNum> ackBlocks = {{1000, 1000}, {701, 900}, {501, 600}};
+  WriteAckFrame::AckBlocks ackBlocks = {{1000, 1000}, {701, 900}, {501, 600}};
   AckFrameMetaData ackMetadata(ackBlocks, 555us, kDefaultAckDelayExponent);
   auto ackFrameWriteResult = writeAckFrame(ackMetadata, pktBuilder);
   EXPECT_FALSE(ackFrameWriteResult.hasValue());
@@ -886,7 +886,7 @@ TEST_F(QuicWriteCodecTest, OnlyHasSpaceForFirstAckBlock) {
   // 2 bytes for largest acked, 2 bytes for ack delay => 4 bytes
   // 1 byte for num ack blocks
   // 1 byte for first ack block length
-  IntervalSet<PacketNum> ackBlocks = {{1000, 1000}, {701, 900}, {501, 600}};
+  WriteAckFrame::AckBlocks ackBlocks = {{1000, 1000}, {701, 900}, {501, 600}};
   AckFrameMetaData ackMetadata(ackBlocks, 555us, kDefaultAckDelayExponent);
   auto ackFrameWriteResult = *writeAckFrame(ackMetadata, pktBuilder);
 
diff --git a/quic/common/IntervalSet-inl.h b/quic/common/IntervalSet-inl.h
index ce1ef273d..c503ac307 100644
--- a/quic/common/IntervalSet-inl.h
+++ b/quic/common/IntervalSet-inl.h
@@ -10,10 +10,7 @@
 
 namespace quic {
 
-template <
-    typename T,
-    T Unit,
-    template <typename I, typename = std::allocator<I>> class Container>
+template <typename T, T Unit, template <typename... I> class Container>
 IntervalSet<T, Unit, Container>::IntervalSet(
     std::initializer_list<Interval<T, Unit>> intervals) {
   for (auto itr = intervals.begin(); itr != intervals.end(); ++itr) {
@@ -21,10 +18,7 @@ IntervalSet<T, Unit, Container>::IntervalSet(
   }
 }
 
-template <
-    typename T,
-    T Unit,
-    template <typename I, typename = std::allocator<I>> class Container>
+template <typename T, T Unit, template <typename... I> class Container>
 void IntervalSet<T, Unit, Container>::insert(
     const Interval<T, Unit>& interval) {
   auto intersectionRange = intersectingRange(interval);
@@ -47,10 +41,7 @@ void IntervalSet<T, Unit, Container>::insert(
   container_type::erase(std::next(firstIt), endIt);
 }
 
-template <
-    typename T,
-    T Unit,
-    template <typename I, typename = std::allocator<I>> class Container>
+template <typename T, T Unit, template <typename... I> class Container>
 void IntervalSet<T, Unit, Container>::withdraw(
     const Interval<T, Unit>& interval) {
   auto intersectionRange = intersectingRange(interval);
@@ -87,10 +78,7 @@ void IntervalSet<T, Unit, Container>::withdraw(
   container_type::erase(erasureStart, erasureEnd);
 }
 
-template <
-    typename T,
-    T Unit,
-    template <typename I, typename = std::allocator<I>> class Container>
+template <typename T, T Unit, template <typename... I> class Container>
 void IntervalSet<T, Unit, Container>::insert(const T& startIt, const T& endIt) {
   if (UNLIKELY(startIt > endIt)) {
     throw std::invalid_argument("Trying to insert invalid interval");
@@ -98,18 +86,12 @@ void IntervalSet<T, Unit, Container>::insert(const T& startIt, const T& endIt) {
   insert(Interval<T, Unit>(startIt, endIt));
 }
 
-template <
-    typename T,
-    T Unit,
-    template <typename I, typename = std::allocator<I>> class Container>
+template <typename T, T Unit, template <typename... I> class Container>
 void IntervalSet<T, Unit, Container>::insert(const T& point) {
   insert(Interval<T, Unit>(point, point));
 }
 
-template <
-    typename T,
-    T Unit,
-    template <typename I, typename = std::allocator<I>> class Container>
+template <typename T, T Unit, template <typename... I> class Container>
 auto IntervalSet<T, Unit, Container>::intersectingRange(
     const Interval<T, Unit>& interval) -> decltype(auto) {
   auto firstIt = std::lower_bound(
@@ -128,10 +110,7 @@ auto IntervalSet<T, Unit, Container>::intersectingRange(
   return std::make_pair(firstIt, endIt);
 }
 
-template <
-    typename T,
-    T Unit,
-    template <typename I, typename = std::allocator<I>> class Container>
+template <typename T, T Unit, template <typename... I> class Container>
 uint64_t IntervalSet<T, Unit, Container>::insertVersion() const {
   return insertVersion_;
 }
diff --git a/quic/common/IntervalSet.h b/quic/common/IntervalSet.h
index 6f05cb525..290929f0f 100644
--- a/quic/common/IntervalSet.h
+++ b/quic/common/IntervalSet.h
@@ -52,8 +52,7 @@ struct Interval {
 template <
     typename T,
     T Unit = (T)1,
-    template <typename I, typename = std::allocator<I>> class Container =
-        std::deque>
+    template <typename... I> class Container = std::deque>
 class IntervalSet : private Container<Interval<T, Unit>> {
  public:
   using interval_type = Interval<T, Unit>;
@@ -91,7 +90,6 @@ class IntervalSet : private Container<Interval<T, Unit>> {
   using container_type::empty;
   using container_type::front;
   using container_type::pop_back;
-  using container_type::pop_front;
   using container_type::size;
 
  private:
diff --git a/quic/common/test/IntervalSetTest.cpp b/quic/common/test/IntervalSetTest.cpp
index 3489d11f0..20cb3296c 100644
--- a/quic/common/test/IntervalSetTest.cpp
+++ b/quic/common/test/IntervalSetTest.cpp
@@ -28,12 +28,12 @@ TEST(IntervalSet, insertAtFront) {
   auto version2 = set.insertVersion();
   set.insert(1, 2);
   auto version3 = set.insertVersion();
-  auto interval = set.front();
-  EXPECT_EQ(interval, Interval<int>(1, 2));
-  set.pop_front();
-  interval = set.front();
+  auto interval = set.back();
   EXPECT_EQ(interval, Interval<int>(4, 5));
-  set.pop_front();
+  set.pop_back();
+  interval = set.back();
+  EXPECT_EQ(interval, Interval<int>(1, 2));
+  set.pop_back();
   EXPECT_TRUE(set.empty());
   EXPECT_GT(version2, version1);
   EXPECT_GT(version3, version2);
@@ -143,7 +143,7 @@ TEST(IntervalSet, insertWithMergeAtEdge) {
   set.insert(3, 3);
   auto interval = set.front();
   EXPECT_EQ(interval, Interval<int>(1, 7));
-  set.pop_front();
+  set.pop_back();
   EXPECT_TRUE(set.empty());
 }
 
diff --git a/quic/common/test/TestUtils.cpp b/quic/common/test/TestUtils.cpp
index 07232ec85..9510ddeb9 100644
--- a/quic/common/test/TestUtils.cpp
+++ b/quic/common/test/TestUtils.cpp
@@ -88,7 +88,7 @@ PacketNum rstStreamAndSendPacket(
 RegularQuicPacketBuilder::Packet createAckPacket(
     QuicConnectionStateBase& dstConn,
     PacketNum pn,
-    IntervalSet<PacketNum>& acks,
+    WriteAckFrame::AckBlocks& acks,
     PacketNumberSpace pnSpace,
     const Aead* aead) {
   // This function sends ACK to dstConn
diff --git a/quic/common/test/TestUtils.h b/quic/common/test/TestUtils.h
index 3d8fe71cc..5ab2ea9b7 100644
--- a/quic/common/test/TestUtils.h
+++ b/quic/common/test/TestUtils.h
@@ -55,7 +55,7 @@ const RegularQuicWritePacket& writeQuicPacket(
 RegularQuicPacketBuilder::Packet createAckPacket(
     QuicConnectionStateBase& dstConn,
     PacketNum pn,
-    IntervalSet<PacketNum>& acks,
+    WriteAckFrame::AckBlocks& acks,
     PacketNumberSpace pnSpace,
     const Aead* aead = nullptr);
 
diff --git a/quic/logging/QLoggerTypes.h b/quic/logging/QLoggerTypes.h
index be77a2fed..f24704880 100644
--- a/quic/logging/QLoggerTypes.h
+++ b/quic/logging/QLoggerTypes.h
@@ -155,11 +155,11 @@ class ReadAckFrameLog : public QLogFrame {
 
 class WriteAckFrameLog : public QLogFrame {
  public:
-  IntervalSet<PacketNum> ackBlocks;
+  WriteAckFrame::AckBlocks ackBlocks;
   std::chrono::microseconds ackDelay;
 
   WriteAckFrameLog(
-      IntervalSet<PacketNum> ackBlocksIn,
+      const WriteAckFrame::AckBlocks& ackBlocksIn,
       std::chrono::microseconds ackDelayIn)
       : ackBlocks{ackBlocksIn}, ackDelay{ackDelayIn} {}
   ~WriteAckFrameLog() override = default;
diff --git a/quic/server/test/QuicServerTransportTest.cpp b/quic/server/test/QuicServerTransportTest.cpp
index 2b26786e7..d5d204b39 100644
--- a/quic/server/test/QuicServerTransportTest.cpp
+++ b/quic/server/test/QuicServerTransportTest.cpp
@@ -552,7 +552,7 @@ class QuicServerTransportTest : public Test {
 
     auto aead = getInitialCipher();
     auto headerCipher = getInitialHeaderCipher();
-    IntervalSet<quic::PacketNum> acks;
+    WriteAckFrame::AckBlocks acks;
     auto start = getFirstOutstandingPacket(
                      server->getNonConstConn(), PacketNumberSpace::Initial)
                      ->packet.header.getPacketSequenceNum();
@@ -943,7 +943,7 @@ TEST_F(QuicServerTransportTest, TestCloseConnectionWithNoErrorPendingStreams) {
   server->writeChain(streamId, IOBuf::copyBuffer("hello"), true, false);
   loopForWrites();
 
-  IntervalSet<quic::PacketNum> acks;
+  WriteAckFrame::AckBlocks acks;
   auto start = getFirstOutstandingPacket(
                    server->getNonConstConn(), PacketNumberSpace::AppData)
                    ->packet.header.getPacketSequenceNum();
@@ -1188,7 +1188,7 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) {
   }
 
   auto originalRetransSize = stream->retransmissionBuffer.size();
-  IntervalSet<PacketNum> acks = {{packetNum1, packetNum1}};
+  WriteAckFrame::AckBlocks acks = {{packetNum1, packetNum1}};
   auto packet1 = createAckPacket(
       server->getNonConstConn(),
       ++clientNextAppDataPacketNum,
@@ -1215,7 +1215,7 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) {
   EXPECT_EQ(stream->sendState, StreamSendState::Open_E);
   EXPECT_EQ(stream->recvState, StreamRecvState::Open_E);
 
-  IntervalSet<PacketNum> acks2 = {{packetNum1, lastPacketNum}};
+  WriteAckFrame::AckBlocks acks2 = {{packetNum1, lastPacketNum}};
   auto packet3 = createAckPacket(
       server->getNonConstConn(),
       ++clientNextAppDataPacketNum,
@@ -1237,7 +1237,7 @@ TEST_F(QuicServerTransportTest, TestOpenAckStreamFrame) {
           server->getNonConstConn(), PacketNumberSpace::AppData)
           ->packet.header.getPacketSequenceNum();
 
-  IntervalSet<PacketNum> acks3 = {{lastPacketNum, finPacketNum}};
+  WriteAckFrame::AckBlocks acks3 = {{lastPacketNum, finPacketNum}};
   auto packet4 = createAckPacket(
       server->getNonConstConn(),
       ++clientNextAppDataPacketNum,
@@ -1769,7 +1769,7 @@ TEST_F(QuicServerTransportTest, TestAckStopSending) {
   auto op = findOutstandingPacket(server->getNonConstConn(), match);
   ASSERT_TRUE(op != nullptr);
   PacketNum packetNum = op->packet.header.getPacketSequenceNum();
-  IntervalSet<PacketNum> acks = {{packetNum, packetNum}};
+  WriteAckFrame::AckBlocks acks = {{packetNum, packetNum}};
   auto packet1 = createAckPacket(
       server->getNonConstConn(),
       ++clientNextAppDataPacketNum,
@@ -1817,7 +1817,7 @@ TEST_F(QuicServerTransportTest, TestAckRstStream) {
       *stream,
       GenericApplicationErrorCode::UNKNOWN);
 
-  IntervalSet<PacketNum> acks = {{packetNum, packetNum}};
+  WriteAckFrame::AckBlocks acks = {{packetNum, packetNum}};
   auto packet1 = createAckPacket(
       server->getNonConstConn(),
       ++clientNextAppDataPacketNum,
@@ -3245,7 +3245,7 @@ TEST_F(QuicUnencryptedServerTransportTest, TestUnencryptedStream) {
 TEST_F(QuicUnencryptedServerTransportTest, TestUnencryptedAck) {
   auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
   server->getNonConstConn().qLogger = qLogger;
-  IntervalSet<PacketNum> acks = {{1, 2}};
+  WriteAckFrame::AckBlocks acks = {{1, 2}};
   auto expected = IOBuf::copyBuffer("hello");
   PacketNum nextPacketNum = clientNextInitialPacketNum++;
   LongHeader header(
diff --git a/quic/state/AckStates.h b/quic/state/AckStates.h
index c2ca68573..86cddc6c7 100644
--- a/quic/state/AckStates.h
+++ b/quic/state/AckStates.h
@@ -15,7 +15,7 @@ namespace quic {
 
 // Ack and PacketNumber states. This is per-packet number space.
 struct AckState {
-  using Acks = IntervalSet<PacketNum>;
+  using Acks = WriteAckFrame::AckBlocks;
   Acks acks;
   // Largest ack that has been written to a packet
   folly::Optional<PacketNum> largestAckScheduled;