Using LINQ or Lambda instead of nested and multiple foreach statements

Since you mentioned in the comments that you want the union of the two lists, you could perform a LINQ Union.

One option is to implement IEquatable<Person> and override GetHashCode on Person.
For simplicity, my example will look only at the Value property:

public class Person : IEquatable<Person>
{
    public int prodId { get; set; }
    public string Value { get; set; }
    public int domainId { get; set; }
    public string Name { get; set; }
    public override bool Equals(object obj)
    {
       return Equals(obj as Person);
    }

    public override int GetHashCode()
    {
       return Value == null ? 0 : Value.GetHashCode();
    }

    public bool Equals(Person other)
    {
       return other != null
              && other.Value == Value;
    }
}

Example usage:

static void Main(string[] args)
{
    var list1 = new List<Person>
                {
                   new Person {Value = "bob"},
                   new Person {Value = "alice"},
                };

    var list2 = new List<Person>
                {
                   new Person {Value = "bob"},
                   new Person {Value = "charles"},
                };

    var unionedList = list1.Union(list2).ToList();
}

Alternatively, you could use @Heslacher's equality comparer and the Union overload which takes in the comparer.

static void Main(string[] args)
{
    var list1 = new List<Person>
                {
                   new Person {Value = "bob"},
                   new Person {Value = "alice"},
                };

    var list2 = new List<Person>
                {
                   new Person {Value = "bob"},
                   new Person {Value = "charles"},
                };

    var unionedList = list1.Union(list2, new PersonValueComaparer()).ToList();
}

Finally, since you want secondList to win in any conflicts, you would use secondList.Union(firstList), so any matches would defer to the objects in secondList.

How about this:

var peopleToAdd = secondList.Where(p1 => initialList.Any(p2 => p1.Value == p2.Value));
initialList.RemoveAll(p1 => secondList.Any(p2 => p1.Value == p2.Value));
initialList.AddRange(peopleToAdd);

Step 1 - look at the second list and find all people that need to be added to the first list. We are looking for all the people that have the same Value in both lists.

var peopleToAdd = secondList.Where(p1 => initialList.Any(p2 => p1.Value == p2.Value));

Step 2 - Remove all the people from the first list that occur in the second list with the same Value.

initialList.RemoveAll(p1 => secondList.Any(p2 => p1.Value == p2.Value));

Note: Micro-optimization for the Step 2, you can use peopleToAdd instead of secondList since we've already discovered matching people.

initialList.RemoveAll(p1 => peopleToAdd.Any(p2 => p1.Value == p2.Value));

Step 3 - add all the people found in Step 1 to the initialList.

initialList.AddRange(peopleToAdd);

By using an IEqualityComparer<Person> which only compares the Value property like

public class PersonValueComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        if (x == null && y == null) { return true; }
        if (x == null || y == null) { return false; }

        return x.Value == y.Value;
    }

    public int GetHashCode(Person obj)
    {
        if (obj == null || obj.Value == null) {return 0;}
        return obj.Value.GetHashCode();
    }
}  

you can by using linq methods replace the loops by

        PersonValueComparer valueComparer = new PersonValueComparer();
        initialList = secondList.Where(p => initialList.Contains(p, valueComparer))
            .Concat(initialList.Where(p => !secondList.Contains(p, valueComparer))).ToList();

We are first using the Where() method to filter the secondList for items which are in the initialList . Then we use Concat() to add the Person''s which are not in thesecondList`.

Based on the naming guidelines properties should be named using PascalCase casing.

You should always use meaningful and descriptive names for naming methods, variables, properties and classes so Sam the Maintainer sees at first glance what it is about.

Shortening variable names doesn't add any value but instead reduces readability which Sam the Maintainer doesn't like.

What you are actually doing is updating the initialList with objects from secondList based on matching Value. The optimal solution would have an O(N+M) comparisons (N and M - number of elements in both lists, while your solution performs O(N*M) comparisons.

In order to make your code simpler I suggest to use the lookup table like this:

var lookup = secondList.ToLookup(person => person.Value);

initialList = initialList
    .Select(person => lookup[person.Value].FirstOrDefault() ?? person).ToList();

We "walk" through the secondList collection once to build a lookup table, and go through the initialList list once to replace elements that match the item in lookup.