Custom Brick Pet Portraits: How to Commission a Model That Captures Your Pet

A custom brick pet portrait turns photographs and personal details into a model designed around the features you recognise immediately. The strongest commissions begin with a clear main photograph, a characteristic pose, essential coat markings, and a decision about whether the portrait is primarily for building or display. You do not need a polished brief: photographs, rough notes, and a short explanation of what makes the pet distinctive are enough to begin discussing the project.

What a Custom Brick Pet Portrait Can Capture

A custom brick pet portrait is an interpretation rather than a photographic copy. Its recognisability comes from selecting the right combination of shape, proportions, colour areas, posture, and familiar details. A successful design does not need to reproduce every strand of fur if it captures the ears, face, markings, and stance that define the pet.

The intended use also affects the design. A compact display portrait may place greater emphasis on the face, while a full-body pet model made from bricks can show a curled tail, raised paw, sitting position, or distinctive body shape. A scene might add a favourite blanket, garden spot, or resting place when that context is central to the memory.

Belle-Ve Bricks can begin with photographs, personal stories, rough notes, or other visual references. Before enquiring, consider five decisions: the essential features, preferred pose, important colours, intended scale, and desired project format. These choices give the design a practical hierarchy without requiring you to solve every detail yourself.

Start With the Details People Recognise First

Begin by listing the features that would make the portrait unmistakably your pet. These might include upright or floppy ears, a broad muzzle, a facial patch, different-coloured paws, a curled tail, or a collar worn every day. Expression and posture can be just as important as coat colour.

Separate these details into must-haves and nice-to-haves. A black-and-white dog, for example, might be recognised principally by a patch over one eye, a tilted head, and one ear that sits lower than the other. Reproducing those three traits may matter more than including every subtle variation in the coat.

Think beyond physical characteristics when choosing the priorities. Perhaps the pet always sat with its front paws crossed, carried the same toy, or wore a bright collar on family walks. Mentioning these habits helps distinguish a personal portrait from a general model of the same breed or species.

Choose Reference Photos That Give a Clear View

Choose one photograph that best represents the portrait you have in mind. This main image should ideally show the face, expression, and preferred pose without furniture, clothing, or another animal obscuring important features. Natural or neutral lighting is useful because heavy shadows and filters can make coat colours difficult to interpret.

Add supporting photographs from the front, side, and rear where available. These extra views can clarify ear shape, muzzle length, body proportions, tail position, and markings hidden in the main image. They do not need to be professionally taken or show the same pose.

An imperfect photograph can still be a useful starting point when accompanied by accurate notes. If a dark image hides a white chest marking, explain its size and shape or supply another image showing it. If the pet’s coat changed with age, state which period the portrait should represent.

Gathering Photos for a Surprise Gift

For a surprise personalised brick pet gift, start with photographs already shared by the recipient or family. Someone close to the pet may be able to confirm markings, eye colour, or a favourite pose without revealing the commission. It is better to ask discreetly for clarification than to guess at a defining feature.

Pick a Pose That Feels Like Your Pet

The best pose is usually the one the recipient will recognise, not necessarily the most dramatic photograph. A head tilt, alert ears, curled sleeping position, or upright sitting posture can communicate personality with a clear silhouette. Highly active poses may require more structural interpretation and can distract from the pet’s defining features.

Common pose options for a custom brick pet portrait

Pose	Best suited to	Points to consider
Head and shoulders	Facial markings, expressions, and compact display pieces	Body shape and tail will not form part of the portrait
Seated full body	Dogs and cats with a recognisable upright posture	Show the front, side, and tail position in supporting photos
Standing	Distinctive body shape, leg markings, or an alert stance	Choose a clear viewing angle and avoid obscured legs
Lying down	A familiar resting position or relaxed character	Provide images that clarify how the legs and tail are arranged
Pet in a small scene	A portrait connected to a bed, blanket, garden, or favourite place	Keep the setting selective so the pet remains the focus

Tell the designer whether the priority is a display portrait, a small scene, or a gift that the recipient can build. A dog portrait brick model intended for a shelf may benefit from a stable, readable pose. A buildable version may require different decisions about scale, construction, and the level of fine detail.

How Colours and Markings Are Interpreted

Brick-built colour interpretation focuses on the relationships that make the pet recognisable. Rather than reproducing every tonal change in a coat, the design can prioritise the contrast between the main coat, muzzle, chest, paws, ears, and distinctive patches. This keeps the markings readable at the selected scale.

Flag any colour that should not be overlooked, including eye colour, a lighter muzzle, a dark tail tip, or an everyday collar. If photographs show different colours because of lighting, explain which image is most accurate. Exact reproduction of every shade or specialist element should not be assumed, so colour priorities are agreed through the design process.

Review the Digital Design Preview Carefully

Belle-Ve Bricks provides a digital design preview so the important shape, scale, colours, and details can be agreed before production. This is the point to compare the proposed portrait with the reference photographs and your must-have list. Concentrate first on recognisability, then consider smaller decorative details.

• Face and muzzle: Does the overall shape reflect the pet?
• Ears: Are their size, angle, and position characteristic?
• Proportions: Does the relationship between the head, body, and legs feel right?
• Markings: Are the defining patches placed clearly?
• Pose: Does the silhouette resemble the familiar posture?
• Collar or accessory: Is it necessary, recognisable, and appropriately scaled?
• Base or setting: Does it support the portrait without drawing attention away from the pet?

Give specific feedback tied to the references. Comments such as “the left ear usually folds forward” or “the white chest patch should be narrower” provide clearer direction than saying the portrait does not look quite right. If an accessory makes the composition too busy, simplifying it may leave more visual emphasis on the pet.

Choose the Right Project Format

Custom model design is the core service: the portrait is developed from the agreed references and brief. Digital building instructions can be considered when the recipient would enjoy assembling the model. This can make the building process part of the gift rather than treating the completed portrait as the only experience.

Optional brick sourcing can be discussed separately. Physical bricks are not automatically included with a design or set of digital instructions unless the specific offer says they are included. Confirm the proposed deliverables before approving the commission so you know whether you will receive a design, instructions, sourced parts, or a fuller project package.

Pre-assembled delivery is available only for suitable selected projects. Custom printed packaging may also be optional or recommended where appropriate rather than forming a standard part of every pet portrait commission. The right route depends on how the portrait will be handed over, built, transported, and displayed.

Projects typically start from £395, but this is not a fixed final price. The quote depends on the model, parts, quantity, packaging, production, delivery, and wider project requirements. A compact digital design and a supplied physical model therefore involve different scopes even when they depict the same pet.

Add Personal Details With a Clear Purpose

The most meaningful additions are usually details rooted in daily life. A favourite collar, blanket, toy, sofa corner, or patch of garden can provide context without turning the portrait into an overloaded scene. A small name detail may also be worth discussing when it suits the format.

A pet portrait can mark a birthday, a new home, a family milestone, a thank-you, or a remembrance project. For an example of how familiar details can guide the concept, see Poppy: A Pet Portrait in Brick for a Dog Like No Other. The connection comes from features and memories the recipient understands, not decoration added without a reason.

Consider the handover moment when selecting the format. If the recipient enjoys building, instructions and sourced parts may be central to the experience. If the portrait is intended for immediate display, ask which suitable supply or assembly routes can be considered for the project.

A Simple Brief to Send With Your Enquiry

You do not need to prepare a formal specification. Gather the information below and identify anything about which you are uncertain. The design conversation can then establish what is practical at the proposed scale and which details deserve priority.

• The pet’s name and species or breed, where known
• One main photograph that represents the desired portrait
• Supporting photographs showing additional angles and markings
• A short list of must-have features
• The preferred pose or a few pose options
• The intended recipient and occasion
• Any meaningful collar, toy, place, or accessory
• Whether the priority is building, display, or both
• The desired format, if already known
• Any practical display-space or handover considerations

Rough notes and photographs are enough to start. Discuss a custom brick model project with the Belle-Ve Bricks team, explaining which features make the pet immediately recognisable and how you want the finished portrait to be experienced.

---

Belle-Ve Bricks is an independent service and is not affiliated with, endorsed by, or sponsored by the LEGO® Group.

Related Reading

• Poppy: A Pet Portrait in Brick for a Dog Like No OtherThe Vision Poppy’s owner wanted to celebrate her first birthday with something personal a custom brick-built model of…
• Custom Brick Model Sets Made to Order, Packaged and Shipped WorldwideThis is the complete Belle-Ve Bricks service. You bring the idea, we handle everything else. Design, supplying the…
• Custom Brick Printing: Logos, Artwork and Graphics Printed Directly onto BricksIf you want your logo, artwork, or a custom graphic printed directly onto a brick, tile or part,…
• Custom Large Scale Brick Sculptures and Display Models Made to CommissionSome projects go beyond a desk model or a gift set. A two metre tall figure built from…

<div class="badge-base LI-profile-badge" data-locale="en_US" data-size="large" data-theme="dark" data-type="HORIZONTAL" data-vanity="ferdi-vol" data-version="v1"><a class="badge-base__link LI-simple-link" href="https://www.linkedin.com/in/%E2%9C%85-ferdi-vol-corporate-gifts/?trk=profile-badge"></a></div>

/* Auto generated, hash = 5dceu9kevqjdyuy2uw1atqrsu */
//TODO: Break this file down so that we can actually unit test it.
(function(window) {
  /**
  * Renders all unrendred LinkedIn Badges on the page
  */
  window.LIRenderAll = function () {
    var CALLBACK_NAME     = 'LIBadgeCallback', //Must match callback on helpers.js
        BADGE_NAMES       = '.LI-profile-badge, .LI-entity-badge',
        // TODO -- tracking param for other badge types
        TRACKING_PARAM    = 'profile-badge',
        responsesReceived = 0, //Keeps track of number of responses recieved for proper cleanup when finished
        expectedResponses = 0, //Keeps track of number of responses to expect
        scripts           = [ ], //Keeps track of scripts added for proper cleanup when finished
        childScripts      = {}, //Keeps track of child scripts to render
        badges            = Array.prototype.slice.call(document.querySelectorAll(BADGE_NAMES));

    var i, len, badge, rendered;
    for (i = 0, len = badges.length;  i < len; i++) {
      badge    = badges[i];
      rendered =  badge.getAttribute('data-rendered');
      if (!rendered) {
        expectedResponses++;
        badge.setAttribute('data-rendered', true);
        renderBadge(badge);
      }
    }

    function isCNDomain() {
      if (typeof window !== "undefined") {
        var hostName = window.location && window.location.hostname ||  '';
        return (/linkedin(-ei)?.cn$/).test(hostName);
      }

      return false;
    }

    function generateUrl(isEI) {
      var domainPrefix = isEI ? 'https://badges.linkedin-ei' : 'https://badges.linkedin';
      if (isCNDomain()) {
        return domainPrefix + ".cn/";
      }

      return domainPrefix + ".com/";
    }

    function getBadgeKeyQueryParams(badge) {
      return Array.prototype.slice.call(badge.attributes).filter(function (attr) {
        return attr.name.lastIndexOf('data-key-', 0) !== -1;
      }).map(function (attr) {
        // Most browsers automatically lowercase the attribute name when its being read
        // We are calling lowercase on it again to ensure consistency for any browsers that are lagging behind.
        return encodeURIComponent(attr.name.replace('data-', '').toLowerCase()) + '=' + encodeURIComponent(attr.value);
      });
    }

    /*
    * Renders a single badge on the page
    * @param badge: div element of badge to render
    */
    function renderBadge(badge) {
      var size       = badge.getAttribute('data-size'),
          locale     = badge.getAttribute('data-locale'),
          type       = badge.getAttribute('data-type'),
          theme      = badge.getAttribute('data-theme'),
          vanity     = badge.getAttribute('data-vanity'),
          version    = badge.getAttribute('data-version'),
          isEI       = badge.hasAttribute('data-ei'),
          entity     = badge.getAttribute('data-entity'),
          isCreatePage = badge.hasAttribute('data-iscreate'),
          uid        = Math.round(1000000 * Math.random()),
          baseUrl = generateUrl(isEI),
          queryParams = [
            'locale=' + encodeURIComponent(locale),
            'badgetype=' + encodeURIComponent(type),
            'badgetheme=' + encodeURIComponent(theme),
            'uid=' + encodeURIComponent(uid),
            'version=' + encodeURIComponent(version)
          ],
          url;

      if (version === 'v2') {
        baseUrl += 'view';
        queryParams.push('badgesize=' + encodeURIComponent(size));
        queryParams.push('entity=' + encodeURIComponent(entity));
        queryParams = queryParams.concat(getBadgeKeyQueryParams(badge));
      } else {
        baseUrl += 'profile';
        queryParams.push('maxsize=' + encodeURIComponent(size));
        queryParams.push('trk=' + encodeURIComponent(TRACKING_PARAM));
        queryParams.push('vanityname=' + encodeURIComponent(vanity));
      }

      if (isCreatePage) {
        queryParams.push('fromCreate=true');
      }

      url = baseUrl + '?' + queryParams.join('&');
      badge.setAttribute('data-uid' , uid);
      jsonp(url); //Calls responseHandler when done
    }

    /**
    * Handles a response from the server. Finds badge matching badgeUid and inserts badgeHtml there
    * @param badgeHtml: String representing contents of the badge
    * @param badgeUid: UID of the badge to target
    **/
    function responseHandler(badgeHtml, badgeUid) {
      responsesReceived ++;

      var i, badge, uid, isCreate;
      var defaultWidth = 330 // max possible width
      var defaultHeight = 300 // max possible height

      for (i = 0, len = badges.length; i < len; i++) {
        badge = badges[i];
        // isCreate needed to prevent reloading artdeco script tag
        isCreate = badge.getAttribute('data-iscreate');
        uid   = parseInt(badge.getAttribute('data-uid'), 10);
        if (uid === badgeUid) {
          var badgeMarkup = `<body>${badgeHtml}</body>`
          var iframe = document.createElement('iframe');
          iframe.onload = function() {
            var iframeBody = iframe.contentWindow.document.body;
            // 5 px buffer to avoid the badge border being cut off.
            iframe.setAttribute('height', (iframeBody.scrollHeight || defaultHeight) + 5);
            iframe.setAttribute('width', (iframeBody.scrollWidth || defaultWidth) + 5);
          };
          iframe.setAttribute('frameBorder', '0');
          iframe.style.display = 'block';
          badge.appendChild(iframe);
          iframe.contentWindow.document.open();
          iframe.contentWindow.document.write(badgeMarkup);
          iframe.contentWindow.document.close();
          replaceScriptTags(badge, isCreate);
        }
      }
      tryClean();
    }

  // These functions are needed because badge markup is added via innerHtml property which does not run script tags
  function replaceScriptTags(node, isCreate) {
    if (shouldReplaceNode(node, isCreate)) {
      node.parentNode.replaceChild(cloneScriptNode(node), node);
      childScripts[node.src] = true;
    } else {
      var i = 0,
          children = node.childNodes;
      while (i < children.length) {
        replaceScriptTags(children[i++], isCreate);
      }
    }
    return node;
  }

  function shouldReplaceNode(node, isCreate) {
    return isScriptNode(node) && !childScripts[node.src] && (!isCreate || (isCreate && !node.getAttribute('data-isartdeco')));
  }

  function isScriptNode(node) {
    return node.tagName === 'SCRIPT';
  }

  function cloneScriptNode(node){
    var script  = document.createElement("script");
    for( var i = node.attributes.length-1; i >= 0; i-- ) {
      script.setAttribute( node.attributes[i].name, node.attributes[i].value );
    }
    return script;
  }

    // Gets all incoming responses
    window[CALLBACK_NAME] = responseHandler;

    /**
    * Tries to clean added tags
    **/
    function tryClean() {
      //Clean up after all requests are done..
      //Accounts for people including script more than once
      var done = (responsesReceived >= expectedResponses && expectedResponses > 0) || responsesReceived >= badges.length;
      if (done) {
        delete window[CALLBACK_NAME];

        // remove all script tags
        scripts.map(function(script){
          document.body.removeChild(script);
        });

      }
    }

    /*
    * Makes Jsonp request, responses handles by CALLBACK_NAME
    * @param url String: url of server to make request to
    */
    function jsonp(url) {
      var script = document.createElement('script');
      script.src = url;
      scripts.push(script);
      document.body.appendChild(script);
    }
  };

  if (document.readyState === 'complete') {
    window.LIRenderAll();
  } else {
    window.addEventListener('load', window.LIRenderAll, false);
  }

})(window);