The NetApp is based on the WAFL (Write Anywhere File Layer) at any given time a file or object is stored via a map of the blocks on the underlying WAFL filesystem. When you make a change to the object the changed block(s) are written into that map. In a heavily simplified example a snapshot is simply a copy of that map at a given time. If blocks subsequently change, there are stored in the current object map. If blocks haven't changed changed than the two maps would be identical in contents. If one block is released in the current map the snapshot would still retain it.
Space wise, a snapshot is a static reference to the blocks on the underlying filesystem. This would effectively make those blocks read-only. A changed block is written elsewhere (and refrenced back by pointers). In a simple world. all writes would only be written to empty blocks, and only after the WAFL determines that they are no longer referenced by an map would they be released for reuse. So in short as long as there is a snapshot map, filesystem map, or even a lun map holding onto an pointer, the data won't be lost or overwritten.
1. Now will the snap we took before get these changes or is it necessary to take snaps everytime there is a change in the LUN?
no the underlying snap is always representative of when the snap was taken, no changes, adds or deletes in subsequent snaps or the current volume are seen between snaps
2. What if the data itself is lost in the LUN?
A snapshot (if any exist) would have a previous copy of the data in the LUN
What is the point in having the data pointers when recovery isn't possible when the actual data itself is lost ??
As long as there are still pointers, the data wont be released and would be recoverable