Web API: classi forti o dinamiche?

Il mio metodo web API dovrebbe restituire alcuni dati strutturati sul mio profilo. Per farlo ho creato le seguenti classi POCO:

public class ProfileInfo
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    //....

    public ProfileAddress Address { get; set; }
    public ProfileDriverLicense DriverLicense { get; set; }
    public ProfileEmergency Emergency { get; set; }
    public ProfileEmployment Employment { get; set; }
    public ProfileCompensation Compensation { get; set; }
    public ProfileFuel Fuel { get; set; }
    public ProfileCompanyInfo CompanyInfo { get; set; }
}

public class ProfileAddress
{
    public string Address { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string Zip { get; set; }
}

public class ProfileDriverLicense
{
    //....
}

public class ProfileEmergency
{
    //....
}

public class ProfileEmployment
{
    //....
}

public class ProfileCompensation
{
    //....
}

public class ProfileFuel
{
    //....
}

public class ProfileCompanyInfo
{
    //....
}

Quindi, come puoi vedere, ci sono molte classi POCO che si annidano l'una con l'altra.

metodo di servizio, che riempie e restituisce l'oggetto ProfileInfo:

    public ProfileInfo GetProfile(string username)
    {
        var profile = _db.Drivers.Where(p => p.AspNetUser.UserName == username).Select(k => new ProfileInfo()
        {
            FirstName = k.AspNetUser.FirstName,
            LastName = k.AspNetUser.LastName,
            Username = username,
            Address = new ProfileAddress()
            {
                Address = k.StreetAddress,
                City = k.City,
                State = k.State,
                Zip = k.ZIP
            },
            AvatarUrl = k.AvatarUrl,
            CompanyInfo = new ProfileCompanyInfo()
            {
                //....
            },
            Compensation = new ProfileCompensation()
            {
                //....
            },
            DateOfBirth = k.DOB,
            DriverLicense = new ProfileDriverLicense()
            {
                //....
            },
            Email = k.AspNetUser.UserName,
            Emergency = new ProfileEmergency()
            {
                //....
            },
            Employment = new ProfileEmployment()
            {
                //....
            },
            Fuel = new ProfileFuel()
            {
                //....
            },
            Phone = k.PhoneNo,
            SSN = k.SSN,
            Notes = k.Notes,
            Truck = (k.Truck != null) ? k.Truck.TruckNo : null,
            Trailer = (k.Trailer != null) ? k.Trailer.TrailerNo : null
        }).FirstOrDefault();

        if (profile == null)
            throw new Domain.InvalidDriverException(username);

        return profile;
    }

e metodo WebAPI:

    [HttpGet]
    [Route("MyProfile")]
    public HttpResponseMessage GetProfile()
    {
        string username = GetUsernameFromClaims();
        if (String.IsNullOrWhiteSpace(username))
            return Request.CreateErrorResponse(HttpStatusCode.NotFound, "User not found");

        var profile = _serviceDriver.GetProfile(username);
        return Request.CreateResponse<Domain.POCO.Profile.ProfileInfo>(profile);
    }

funziona e funziona bene Ma qualche vantaggio nell'uso delle lezioni POCO è concreto in questo caso? O posso usare dinamico e avere lo stesso effetto, con molto meno codice e senza svantaggi? Con la dinamica non devo scrivere tutte queste classi POCO e molto facile da modificare. Capisco, quella dinamica funziona molto lentamente, non è facile trovare errori (nessun errore di compilazione), ma nel risultato API Web restituisce JSON, che non è di tipo strong per impostazione predefinita. Che senso creare e utilizzare le classi POCO?

PS. Uso i tipi forti, è più comodo per me :) Ma probabilmente per caso concreto scrivo molto extra-code?