diff --git a/solution.md b/solution.md
index b74136f..17289f8 100644
--- a/solution.md
+++ b/solution.md
@@ -299,7 +299,8 @@ Finally, in main.rs, the driver function mines the block. Main begins by initial
      o	Otherwise, increment the nonce and continue the loop.
 
 ## Results and Performance
-The result has been successful in terms of mining a block above 60 points. But I was disappointed because wasn't able to fill a block. I would have liked to validate p2sh or p2wsh transactions, so I had enough valid transactions to better test the efficiency of my code. In the current state, my script validates every valid p2pkh and p2wpkh transaction and after I add them all to the block, I still have around 500k weight units left over. Overall, after I fixed a few issues, I was able to get my score to 88. I'm still looking forward to writing the validation functions for the script hash transaction types as well as the p2tr transaction types. Next, is efficiency. My solution takes an average of 1.5 minutes to mine. This dropped from close to 10 minutes at the beginning of the project. I did some research and found I could use a buffer (in deserialize_tx()) to read the mempool more efficiently. It helps by reading large chunks of the mempool files at once and then it allows serde to parse the JSON data from the buffer. It ended up being more efficient than reading the file byte per byte (or in small chunks). I also wrote the serialize_block_header() function to serialize the header quickly. The header data is written directly into the pre-allocated buffer (80 bytes) using in-place operations. This allows miners to prepare new block headers for hashing more quickly, effectively reducing the time between hash attempts. This is in contrast to my transaction serialization functions where each field is serialized one at a time and pushed to a vector.
+The results of my project have been promising, earning a score of 88! However, I still have a lot of room for improvement. I would have liked to validate p2sh or p2wsh transactions, so I had enough valid transactions to better test the efficiency of my code. In the current state, my script validates every valid p2pkh and p2wpkh transaction and after I add them all to the block, I still have around 500k weight units left over. So, in the future, I'd wish to improve the number of transaction types I could validate. Throughout the project, I significantly optimized the mining process, reducing the average mining time from nearly 10 minutes to just 1.5 minutes. This improvement stemmed from a key modification in how I handled mempool data: I implemented a buffer in the deserialize_tx() function, which allowed for bulk reading of mempool files. This approach is more efficient than processing data byte-by-byte or in small chunks, as it minimizes read operations and speeds up JSON parsing by serde.
+Further efficiency gains were achieved with the serialize_block_header() function, which directly writes header data into a pre-allocated 80-byte buffer using in-place operations. This method significantly speeds up the preparation of new block headers for hashing, reducing the interval between hash attempts. This stands in contrast to my transaction serialization approach, which serializes fields individually and accumulates them in a vector. Moving forward, I plan to refine these serialization processes to further enhance the efficiency and performance of my mining script.
 ## Conclusion
 Over the past few months during the Summer of Bitcoin boot camp and proposal process, I’ve experienced significant growth as a developer, particularly in my Rust programming skills which I've been honing for almost a year now. The challenge of constructing a valid block not only enhanced my technical proficiency but also deepened my appreciation for the meticulous efforts of long-time bitcoin (and lightning) developers.
 This project was a comprehensive learning journey. Writing script validation code and operating on OP codes was particularly enlightening. Each successful operation was a success, and each failure was a valuable lesson for me. This led to my improved ability to write great tests in Rust. Although I didn't utilize Rust's existing test frameworks, the tests I developed played a crucial role in identifying issues with signature validations and stack operations, in turn enhancing my debugging skills. Another essential learning experience was the importance of thorough research and effective communication. Early in the project, I encountered numerous challenges that could have been mitigated with better prep research or by seeking advice from Discord.