DAILY NEWS

Stay Ahead, Stay Informed – Every Day

Advertisement
Shopify Speed Optimization with Liquid Code (5 Patterns)



I audited 14 Shopify themes last quarter for speed. 11 of them blamed apps. None had touched Liquid loop count, capture-in-loop allocations, or image output.

After optimizing 100+ Shopify stores over 12 years: the code-level patterns in your theme files account for 40-60% of total render time. Apps matter. Images matter. The template layer is where the compounding problems live.

Here are the 5 Liquid patterns that move the needle.

1. Drop capture from loops

assign stores a value. capture renders a full block and stores it as a string. Using capture inside a loop means a new string allocation on every iteration.

Slow — 48 allocations on a 48-product collection:

{% for product in collection.products %}
{% capture product_card %}

{{ product.title }}
{{ product.price | money }}

{% endcapture %}
{{ product_card }}
{% endfor %}

Enter fullscreen mode

Exit fullscreen mode

Fast — direct output, zero allocations:

{% for product in collection.products %}

{{ product.title }}
{{ product.price | money }}

{% endfor %}

Enter fullscreen mode

Exit fullscreen mode

Use capture only when you need a reusable HTML block built once and output in a different location.

2. Cap nested loops with limit and {% break %}

Nested loops are the single biggest source of Liquid render time problems.

Slow — 2,500 iterations on a featured collections section:

{% for collection in collections %}
{% for product in collection.products %}
{% for image in product.images %}
{{ image | image_url: width: 300 }}” alt=”https://dev.to/mdkaspianfuad/{{ image.alt }}”>
{% endfor %}
{% endfor %}
{% endfor %}

Enter fullscreen mode

Exit fullscreen mode

Fast — 32 iterations, using featured_image and limit:

{% for collection in collections limit: 4 %}
{% for product in collection.products limit: 8 %}
{% if product.featured_image %}
{{ product.featured_image | image_url: width: 300 }}”
alt=”https://dev.to/mdkaspianfuad/{{ product.featured_image.alt | default: product.title }}”
width=”300″ height=”300″ loading=”lazy”>
{% endif %}
{% endfor %}
{% endfor %}

Enter fullscreen mode

Exit fullscreen mode

Use {% break %} to stop early once you have the N items you need. Use {% continue %} to skip non-matching items without a nested if.

Real result: Factory Direct Blinds went from 4,800 collection iterations to 216. LCP dropped from 22s to 2.7s.

3. Output images with image_tag (srcset + dimensions)

This single change can improve LCP by 500ms+ on collection pages.

Slow — no srcset, no dimensions, no lazy loading:

{{ product.featured_image | image_url: width: 800 }}”>

Enter fullscreen mode

Exit fullscreen mode

Fast:

{{ product.featured_image | image_url: width: 800 | image_tag:
srcset: “200,400,600,800”,
sizes: “(max-width: 768px) 100vw, 400px”,
loading: “lazy”,
decoding: “async”,
alt: product.featured_image.alt | default: product.title,
width: 800,
height: 800
}}

Enter fullscreen mode

Exit fullscreen mode

Critical: Your hero and first visible product image should use loading: “eager”, not lazy. Lazy-loading your LCP element is one of the most common speed mistakes I see on audits.

To handle this in a grid, conditionally eager-load the first 4:

{% for product in collection.products limit: 24 %}
{% assign img_loading = forloop.index 4 | iif: “eager”, “lazy” %}
{{ product.featured_image | image_url: width: 600 | image_tag:
loading: img_loading,
width: 600,
height: 600
}}
{% endfor %}

Enter fullscreen mode

Exit fullscreen mode

4. Preload hero image and critical font in theme.liquid

{% if template == ‘index’ %}
{% assign hero_image = section.settings.hero_image %}
{% if hero_image %}
{{ hero_image | image_url: width: 1200 }}”
imagesrcset=”https://dev.to/mdkaspianfuad/{{ hero_image | image_url: width: 600 }} 600w, {{ hero_image | image_url: width: 1200 }} 1200w”
imagesizes=”100vw”>
{% endif %}
{% endif %}

{{ ‘your-heading-font.woff2’ | asset_url }}” crossorigin>

Enter fullscreen mode

Exit fullscreen mode

Wrap third-party preconnects in conditionals so they only fire when the feature is enabled:

{% if settings.enable_reviews %}

{% endif %}

Enter fullscreen mode

Exit fullscreen mode

5. Push dynamic content onto the Section Rendering API

Instead of a full page reload to update one section, fetch just that section’s HTML.

Slow — full page reload on filter click:

window.location.href = newUrl;

Enter fullscreen mode

Exit fullscreen mode

Fast — Section Rendering API:

async function updateCollection(url) {
const sectionId = ‘collection-grid’;
const response = await fetch(`${url}?sections=${sectionId}`);
const data = await response.json();
document.getElementById(sectionId).innerHTML = data(sectionId);
}

Enter fullscreen mode

Exit fullscreen mode

Response size drops from 100KB+ to 5-15KB. Perceived load time drops from 2-3 seconds to 200-400ms.

Good candidates: collection filtering, cart drawer, product recommendations, quick-view modals.

Before and after numbers

Store
Metric
Before
After

WD Electronics
Mobile LCP
9.3s
3.1s

WD Electronics
Lighthouse
41
72

WD Electronics
DOM Elements
4,200+
1,100

Factory Direct Blinds
Mobile PageSpeed
38
81

Factory Direct Blinds
LCP
22.0s
2.7s

Factory Direct Blinds
Liquid Render
840ms
65ms

Both stores saw measurable conversion improvements within 30 days of deploying the speed fixes.

How to verify in 5 minutes

Install the Shopify Theme Inspector Chrome extension. Open DevTools, go to the Shopify tab, reload your slowest collection page. Total Liquid render time should be under 100ms. Over 200ms means a section is bleeding render budget.
Open PageSpeed Insights on Mobile. Read Field Data first — that is real Chrome users, the metric Google ranks on.
Check Search Console > Experience > Core Web Vitals for which URL groups are flagged Poor.

The full post (with more code and the FAQ section) is at kaspianfuad.com.

If you want a professional audit of your theme’s Liquid performance, I run a Shopify speed-focused CRO audit that covers every pattern above plus the JS and third-party script layer.



Source link

Building a Translation Pipeline for International Contract Bidding


If your company bids on international contracts, you’ve probably dealt with the translation bottleneck. Technical proposals need precise translation, certified documents have strict formatting requirements, and procurement deadlines don’t wait for anyone.

After seeing how UK public procurement translation requirements can make or break a bid, I’ve been thinking about how developers can build systems to streamline this process. Here’s how to approach translation workflows from a technical perspective.

The Real Problem: Document Workflows, Not Just Translation

Most companies treat translation as a last-minute service purchase. But international bidding is really a document pipeline problem:

Source documents change during proposal development
Different document types need different translation approaches
Version control becomes critical when translators work in parallel
Deadline tracking needs to account for translation time

Core Architecture: Translation-Aware Document Management

Start with a document management system that treats translation as a first-class workflow, not an afterthought.

Document Classification System

class DocumentType(Enum):
TECHNICAL_PROPOSAL = “technical” # Requires specialist translation
LEGAL_CERTIFICATE = “certified” # Needs certified translation
FINANCIAL_STATEMENT = “certified” # Needs certified + formatting
REFERENCE_LETTER = “standard” # Standard business translation
INTERNAL_MEMO = “none” # No translation needed

class Document:
def __init__(self, file_path, doc_type, target_languages):
self.file_path = file_path
self.doc_type = doc_type
self.target_languages = target_languages
self.translation_status = {}
self.version_hash = self.calculate_hash()

def needs_retranslation(self):
current_hash = self.calculate_hash()
return current_hash != self.version_hash

Enter fullscreen mode

Exit fullscreen mode

Translation Queue Management

Build a priority queue that factors in document dependencies and deadlines:

from datetime import datetime, timedelta
import heapq

class TranslationQueue:
def __init__(self):
self.queue = ()
self.translation_times = {
DocumentType.TECHNICAL_PROPOSAL: timedelta(days=5),
DocumentType.LEGAL_CERTIFICATE: timedelta(days=3),
DocumentType.FINANCIAL_STATEMENT: timedelta(days=2),
DocumentType.REFERENCE_LETTER: timedelta(days=1)
}

def add_document(self, document, deadline, priority=0):
translation_time = self.translation_times(document.doc_type)
latest_start = deadline – translation_time

# Priority: earlier deadline = higher priority (lower number)
priority_score = latest_start.timestamp() – priority * 86400

heapq.heappush(self.queue, (
priority_score,
document.file_path,
document
))

def get_next_batch(self, max_concurrent=3):
batch = ()
for _ in range(min(max_concurrent, len(self.queue))):
if self.queue:
_, _, document = heapq.heappop(self.queue)
batch.append(document)
return batch

Enter fullscreen mode

Exit fullscreen mode

Integration Points: APIs and Automation

Translation Service Integration

Most professional translation companies now offer APIs. Here’s a generic wrapper:

import requests
from typing import Dict, List

class TranslationServiceAPI:
def __init__(self, api_key: str, base_url: str):
self.api_key = api_key
self.base_url = base_url
self.headers = {
‘Authorization’: f’Bearer {api_key}’,
‘Content-Type’: ‘application/json’
}

def submit_document(self, document_path: str,
source_lang: str, target_lang: str,
service_level: str = “professional”) -> str:
“””
Submit document for translation
Returns: job_id for tracking
“””
with open(document_path, ‘rb’) as f:
files = {‘document’: f}
data = {
‘source_language’: source_lang,
‘target_language’: target_lang,
‘service_level’: service_level,
‘deadline’: self.calculate_deadline()
}

response = requests.post(
f”{self.base_url}/jobs”,
headers=self.headers,
data=data,
files=files
)

return response.json()(‘job_id’)

def check_status(self, job_id: str) -> Dict:
response = requests.get(
f”{self.base_url}/jobs/{job_id}”,
headers=self.headers
)
return response.json()

Enter fullscreen mode

Exit fullscreen mode

Document Change Detection

Monitor source documents for changes that require retranslation:

import hashlib
import os
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class DocumentChangeHandler(FileSystemEventHandler):
def __init__(self, translation_queue):
self.translation_queue = translation_queue
self.document_hashes = {}

def on_modified(self, event):
if event.is_directory:
return

file_path = event.src_path
if self.is_tracked_document(file_path):
current_hash = self.calculate_file_hash(file_path)
previous_hash = self.document_hashes.get(file_path)

if current_hash != previous_hash:
self.document_hashes(file_path) = current_hash
self.queue_for_retranslation(file_path)

def calculate_file_hash(self, file_path):
hasher = hashlib.md5()
with open(file_path, ‘rb’) as f:
for chunk in iter(lambda: f.read(4096), b””):
hasher.update(chunk)
return hasher.hexdigest()

Enter fullscreen mode

Exit fullscreen mode

Compliance and Quality Control

Automated Format Validation

Certain documents (like certified translations) have strict formatting requirements:

import re
from pathlib import Path

class CertifiedTranslationValidator:
def __init__(self):
self.required_elements = (
r”I hereby certify”,
r”qualified translator”,
r”accurate.*complete”,
r”\(Translator signature\)”,
r”\(Date\)”
)

def validate_certified_translation(self, file_path: str) -> List(str):
errors = ()
content = Path(file_path).read_text()

for pattern in self.required_elements:
if not re.search(pattern, content, re.IGNORECASE):
errors.append(f”Missing required element: {pattern}”)

# Check for proper formatting
if not self.has_proper_layout(content):
errors.append(“Document layout does not match certification requirements”)

return errors

def has_proper_layout(self, content: str) -> bool:
# Implementation depends on specific requirements
# Check margins, font sizes, signature placement, etc.
return True # Simplified for example

Enter fullscreen mode

Exit fullscreen mode

Monitoring and Alerts

Set up alerts for translation bottlenecks and deadline risks:

from datetime import datetime, timedelta
import smtplib
from email.mime.text import MIMEText

class TranslationMonitor:
def __init__(self, email_config):
self.email_config = email_config

def check_deadline_risks(self, translation_queue):
at_risk_jobs = ()
now = datetime.now()

for job in translation_queue.active_jobs:
time_remaining = job.deadline – now
estimated_completion = job.started_at + job.estimated_duration

if estimated_completion > job.deadline:
at_risk_jobs.append(job)

if at_risk_jobs:
self.send_alert(f”{len(at_risk_jobs)} translation jobs at risk of missing deadline”)

def send_alert(self, message):
msg = MIMEText(message)
msg(‘Subject’) = ‘Translation Pipeline Alert’
msg(‘From’) = self.email_config(‘from’)
msg(‘To’) = self.email_config(‘to’)

with smtplib.SMTP(self.email_config(‘smtp_server’)) as server:
server.send_message(msg)

Enter fullscreen mode

Exit fullscreen mode

Putting It Together

Here’s how these components work together in practice:

# Initialize the system
translation_queue = TranslationQueue()
api_client = TranslationServiceAPI(api_key, base_url)
monitor = TranslationMonitor(email_config)

# Set up file monitoring
event_handler = DocumentChangeHandler(translation_queue)
observer = Observer()
observer.schedule(event_handler, path=’./proposals’, recursive=True)
observer.start()

# Main processing loop
while True:
# Process translation queue
batch = translation_queue.get_next_batch()
for document in batch:
job_id = api_client.submit_document(
document.file_path,
document.source_lang,
document.target_lang
)
document.track_job(job_id)

# Check for completed translations
for job in active_jobs:
status = api_client.check_status(job.job_id)
if status(‘completed’):
download_and_validate_translation(job)

# Monitor deadlines
monitor.check_deadline_risks(translation_queue)

time.sleep(300) # Check every 5 minutes

Enter fullscreen mode

Exit fullscreen mode

Next Steps

This pipeline approach transforms translation from a manual bottleneck into a managed workflow. The key is treating it as a technical problem that requires proper tooling, not just a service you buy.

Start small: implement document classification and basic queue management first. Then add monitoring and API integration as your international bidding volume grows.

The goal isn’t to replace human translators but to give them better tools and clearer workflows. When deadline pressure hits, you want systems that work automatically, not spreadsheets that need manual updates.



Source link

Shipping TanStack Start and Bun to Railway



Railway’s Nixpacks autobuild detects Bun projects fine, but it can’t sequence the combination this site needs: prisma generate at build time, Vite + the TanStack Start plugin, a custom server.ts entry, and prisma migrate deploy on boot. A four-stage Dockerfile is simpler than teaching Nixpacks all of that.

The full post walks through the recipe: two parallel bun install stages (one full, one production-only), a build stage that runs prisma generate against a dummy DATABASE_URL, a lean runtime that layers the generated Prisma client on top of deps-prod’s node_modules, and an entrypoint that runs migrations before exec-ing into Bun so the container’s PID 1 shuts down cleanly on Railway’s SIGTERM.

Plus the small Railway-side bits: how to wire the Postgres reference variable, why you should bind explicitly to 0.0.0.0, and the COPY-order detail that determines whether your runtime sees the right Prisma client.

Originally published at andreasbergstrom.dev — read the full post there.



Source link