diff --git a/include/pattern.hpp b/include/pattern.hpp
index 691cb16..e8c61ee 100644
--- a/include/pattern.hpp
+++ b/include/pattern.hpp
@@ -6,12 +6,13 @@
 #include <stdplus/fd/create.hpp>
 #include <stdplus/fd/managed.hpp>
 
+#include <chrono>
 #include <span>
 #include <string>
 
 namespace estoraged
 {
-using stdplus::fd::ManagedFd;
+using stdplus::fd::Fd;
 
 class Pattern : public Erase
 {
@@ -23,29 +24,48 @@
     Pattern(std::string_view inDevPath) : Erase(inDevPath)
     {}
 
+    /** @brief writes an uncompressible random pattern to the drive, using
+     * default parameters. It also throws errors accordingly.
+     */
+    void writePattern()
+    {
+        stdplus::fd::Fd&& fd =
+            stdplus::fd::open(devPath, stdplus::fd::OpenAccess::WriteOnly);
+        writePattern(util::findSizeOfBlockDevice(devPath), fd);
+    }
+
     /** @brief writes an uncompressible random pattern to the drive
      * and throws errors accordingly.
      *
      *  @param[in] bytes - Size of the block device
+     *  @param[in] fd - the stdplus file descriptor
      */
-    void writePattern()
-    {
-        writePattern(util::findSizeOfBlockDevice(devPath));
-    }
+    void writePattern(uint64_t driveSize, Fd& fd);
 
-    void writePattern(uint64_t driveSize);
+    /** @brief verifies the uncompressible random pattern is on the drive, using
+     * default parameters. It also throws errors accordingly.
+     */
+    void verifyPattern()
+    {
+        stdplus::fd::Fd&& fd =
+            stdplus::fd::open(devPath, stdplus::fd::OpenAccess::ReadOnly);
+        verifyPattern(util::findSizeOfBlockDevice(devPath), fd);
+    }
 
     /** @brief verifies the uncompressible random pattern is on the drive
      * and throws errors accordingly.
      *
      *  @param[in] bytes - Size of the block device
+     *  @param[in] fd - the stdplus file descriptor
      */
+    void verifyPattern(uint64_t driveSize, Fd& fd);
 
-    void verifyPattern()
-    {
-        verifyPattern(util::findSizeOfBlockDevice(devPath));
-    }
-    void verifyPattern(uint64_t driveSize);
+  private:
+    static constexpr uint32_t seed = 0x6a656272;
+    static constexpr size_t blockSize = 4096;
+    static constexpr size_t blockSizeUsing32 = blockSize / sizeof(uint32_t);
+    static constexpr size_t maxRetry = 32;
+    static constexpr std::chrono::duration delay = std::chrono::milliseconds(1);
 };
 
 } // namespace estoraged
diff --git a/include/zero.hpp b/include/zero.hpp
index 562b8ce..bfa240d 100644
--- a/include/zero.hpp
+++ b/include/zero.hpp
@@ -6,10 +6,12 @@
 #include <stdplus/fd/create.hpp>
 #include <stdplus/fd/managed.hpp>
 
+#include <chrono>
+
 namespace estoraged
 {
 
-using stdplus::fd::ManagedFd;
+using stdplus::fd::Fd;
 
 class Zero : public Erase
 {
@@ -23,29 +25,35 @@
     /** @brief writes zero to the drive
      * and throws errors accordingly.
      *  @param[in] driveSize - the size of the block device in bytes
+     *  @param[in] fd - the stdplus file descriptor
      */
-    void writeZero(uint64_t driveSize);
+    void writeZero(uint64_t driveSize, Fd& fd);
 
-    /** @brief writes zero to the drive
+    /** @brief writes zero to the drive using default parameters,
      * and throws errors accordingly.
      */
     void writeZero()
     {
-        writeZero(util::findSizeOfBlockDevice(devPath));
+        stdplus::fd::Fd&& fd =
+            stdplus::fd::open(devPath, stdplus::fd::OpenAccess::WriteOnly);
+        writeZero(util::findSizeOfBlockDevice(devPath), fd);
     }
 
-    /** @brief verifies the  uncompressible random pattern is on the drive
+    /** @brief verifies the drive has only zeros on it,
      * and throws errors accordingly.
      *  @param[in] driveSize - the size of the block device in bytes
+     *  @param[in] fd - the stdplus file descriptor
      */
-    void verifyZero(uint64_t driveSize);
+    void verifyZero(uint64_t driveSize, Fd& fd);
 
-    /** @brief verifies the  uncompressible random pattern is on the drive
-     * and throws errors accordingly.
+    /** @brief verifies the drive has only zeros on it,
+     * using the default parameters. It also throws errors accordingly.
      */
     void verifyZero()
     {
-        verifyZero(util::findSizeOfBlockDevice(devPath));
+        stdplus::fd::Fd&& fd =
+            stdplus::fd::open(devPath, stdplus::fd::OpenAccess::ReadOnly);
+        verifyZero(util::findSizeOfBlockDevice(devPath), fd);
     }
 
   private:
@@ -53,6 +61,8 @@
      * 32768 was also tested. It had almost identical performance.
      */
     static constexpr size_t blockSize = 4096;
+    static constexpr size_t maxRetry = 32;
+    static constexpr std::chrono::duration delay = std::chrono::milliseconds(1);
 };
 
 } // namespace estoraged