ZyroByte Tech Blog
ZyroByte Tech Blog
TL;DR: Shippo processes over 200 million shipments per year for 300,000+ businesses. If you want to build a shipping platform with the same capabilities — multi-carrier rate shopping, label generation, tracking, and address validation — this guide covers the architecture, data model, carrier integrations, and development roadmap to get there. ZyroByte builds custom shipping platforms for logistics companies and eCommerce businesses.
What Is Shippo and Why Build Something Like It?
Shippo (GoShippo) is a multi-carrier shipping platform founded in 2013 in San Francisco. It provides a unified API and web dashboard that lets eCommerce businesses compare rates, print labels, track packages, and manage returns across 40+ carriers — including USPS, UPS, FedEx, DHL Express, Canada Post, and Royal Mail.
Shippo’s key numbers tell the story:
- 300,000+ businesses on the platform
- $12 billion+ annual gross merchandise volume
- 200 million+ shipments per year
- 40+ carrier integrations
- Integrations with Shopify, WooCommerce, Amazon, Etsy, BigCommerce, Magento, Walmart, TikTok Shop, and more
So why build your own? Because Shippo is a general-purpose tool. If your business needs custom carrier contracts, proprietary rate logic, specific regional carriers, pickup scheduling, warehouse management, or white-label shipping for your own clients — you need a custom platform. Shippo’s pricing also scales with volume: from free (30 labels/month) to $199/month for 10,000 labels, with enterprise pricing beyond that. A custom platform eliminates per-label fees entirely.
Core Features Every Shipping Platform Needs
Before writing a single line of code, you need to understand what a production shipping platform actually does. Here are the essential capabilities, modeled after what Shippo and similar platforms provide:
1. Multi-Carrier Rate Shopping
The core value proposition. Your platform sends a shipment request (origin, destination, parcel dimensions, weight) and returns real-time rates from multiple carriers in a single API call. Merchants compare prices and delivery times side by side.
Shippo calls this their Rating API. Your version needs to:
- Query multiple carrier APIs in parallel
- Normalize rate responses into a consistent format
- Apply markup rules, discounts, or custom pricing
- Cache rates to reduce carrier API calls and latency
- Handle carrier-specific service levels (Ground, Express, Priority, Overnight)
2. Shipping Label Generation
Once a merchant selects a rate, your platform creates a shipment with the carrier and returns a printable label (PDF or ZPL for thermal printers). This includes:
- Label generation in PDF, PNG, or ZPL format
- Tracking number assignment
- Customs forms and commercial invoices for international shipments
- Batch label creation for high-volume shippers
- Label voiding and refund handling
3. Shipment Tracking
Tracking is where customer experience lives. Your platform needs to ingest tracking events from carriers, normalize them into a standard format, and deliver updates via webhooks or a tracking API.
- Real-time tracking event ingestion (polling or carrier webhooks)
- Status normalization: pre-transit, in-transit, out-for-delivery, delivered, failed, returned
- Webhook delivery to merchant endpoints
- Branded tracking pages (white-label)
- Email/SMS notifications for customers
4. Address Validation
Bad addresses cause failed deliveries. Shippo’s Address API validates and corrects addresses before labels are created. Your platform should:
- Validate addresses against postal databases (USPS, Canada Post, etc.)
- Auto-correct common formatting errors
- Flag undeliverable or incomplete addresses
- Support international address formats
5. Returns Management
Return labels, return tracking, and automated return workflows are essential for eCommerce. Shippo provides this natively — your custom platform should too.
6. Billing and Usage Analytics
If you’re building a multi-tenant SaaS (serving multiple merchants), you need usage tracking, plan management, invoicing, and overage billing. Shippo charges per label; your platform can implement any pricing model you want.
Carrier Integrations: The Hardest Part
The most technically challenging piece of building a shipping platform is carrier API integration and normalization. Every carrier has a different API, different authentication, different data formats, and different error handling.
Why Carrier APIs Are Difficult
| Carrier | API Style | Auth Method | Notable Challenge |
|---|---|---|---|
| UPS | REST (newer) / XML (legacy) | OAuth 2.0 | Complex service level mapping |
| FedEx | REST / SOAP (legacy) | OAuth 2.0 | Sandbox/production credential differences |
| DHL Express | REST | API key | Regional API endpoint differences |
| Canada Post | REST / XML | API key + password | Contract vs. counter rate logic |
| USPS | REST (newer) / XML | API key | eVS label requirements |
| Purolator | SOAP | API key + password | Legacy SOAP-only, complex WSDL |
Your platform needs a carrier adapter layer — a consistent internal interface that each carrier implementation follows. This way, your rate shopping engine doesn’t care whether it’s talking to FedEx REST or Purolator SOAP. The adapter handles the translation.
What Shippo Doesn’t Support: Pickup Scheduling
One notable limitation: Shippo has limited carrier pickup scheduling (only USPS and DHL Express via their app). If your platform needs on-demand or daily scheduled pickups with UPS, FedEx, or Purolator, you’ll need to build those carrier integrations directly. This is a common differentiator for custom shipping platforms.
Platform Architecture
A production shipping platform should be designed as a set of modular services. You can start as a monolith and split later, but plan the service boundaries from day one.
Recommended Service Architecture
| Service | Responsibility |
|---|---|
| Rates Service | Multi-carrier rate requests, caching, margin/markup rules, service level mapping |
| Shipment Service | Label creation, shipment lifecycle, document storage, void/refund |
| Tracking Service | Event ingestion, status normalization, webhook delivery, tracking pages |
| Address Service | Validation, correction, deliverability scoring, international format support |
| Billing Service | Usage metering, plan management, invoicing, overage billing |
| Carrier Gateway | Adapter layer for each carrier API — isolates carrier-specific logic |
| Webhook Engine | Reliable event delivery with retry logic, dead-letter queues, signature verification |
Technology Stack Recommendations
- Backend: Go or Rust for carrier gateway and rate engine (performance-critical); Node.js or Python for billing and webhooks
- Database: PostgreSQL for transactional data; Redis for rate caching and rate limiting
- Queue: RabbitMQ or NATS for async tracking event processing and webhook delivery
- Storage: S3-compatible storage for label PDFs and shipping documents
- Orchestration: K3s or Kubernetes for container orchestration (see our K3s vs Kubernetes guide)
- API: RESTful with OpenAPI docs; optional GraphQL for dashboard queries
Data Model
Your database schema needs to support multi-tenant operations, multiple carriers, and the full shipment lifecycle. Here are the essential entities:
Core Entities
| Entity | Key Fields |
|---|---|
| Account | id, name, email, plan, API keys, usage limits, carrier accounts |
| Shipment | id, account_id, origin_address, destination_address, parcels[], status, carrier, service_level |
| Parcel | id, shipment_id, length, width, height, weight, weight_unit, distance_unit |
| Rate Quote | id, shipment_id, carrier, service, amount, currency, estimated_days, expires_at |
| Label | id, shipment_id, tracking_number, label_url, format (PDF/ZPL), carrier_transaction_id |
| Tracking Event | id, tracking_number, status, status_detail, location, timestamp, carrier_raw |
| Carrier Account | id, account_id, carrier, credentials (encrypted), is_test, region |
| Webhook Subscription | id, account_id, url, events[], secret, is_active |
Security and Compliance
Shipping data includes personal addresses, phone numbers, and sometimes business identifiers. A production platform must handle this responsibly:
- Encrypt carrier credentials — carrier API keys and account numbers stored encrypted at rest (AES-256)
- Tenant isolation — strict data separation between merchant accounts
- API authentication — API key + HMAC signature verification; support for key rotation
- Rate limiting — protect carrier APIs and your own infrastructure from abuse
- Audit logging — every API call, label creation, and credential change logged
- IP allowlists — optional restriction for enterprise API clients
- PCI/SOC 2 — if handling payment data alongside shipping, comply with relevant standards
Development Roadmap: MVP to Production
Shippo started with a small set of carriers and a clean API. Your custom platform should follow a similar phased approach:
Phase 1: Core Shipping (8–12 weeks)
- Rate shopping for 2–3 carriers (e.g., UPS + FedEx + USPS or Canada Post)
- Label generation (PDF)
- Basic shipment management API
- Merchant dashboard (create shipments, view labels)
- API key authentication
Phase 2: Tracking and Webhooks (4–6 weeks)
- Tracking event ingestion and normalization
- Webhook delivery with retry logic
- Branded tracking pages
- Email/SMS notifications
Phase 3: Address Validation and Billing (4–6 weeks)
- Address validation and correction API
- Usage metering and plan management
- Invoicing and overage billing
- International customs forms
Phase 4: Scale and Differentiate (Ongoing)
- Analytics dashboard (shipping spend, carrier performance, delivery times)
- Automated shipping rules engine
- Multi-warehouse support
- Carrier pickup scheduling
- Platform integrations (Shopify, WooCommerce, etc.)
- White-label API for resellers
Build vs. Buy: When Custom Makes Sense
Shippo (and similar platforms like EasyPost and Flagship) work well for businesses that need standard shipping features without customization. But a custom shipping platform makes sense when:
- You need proprietary rate logic — custom margins, carrier-negotiated rates, or dynamic pricing rules that Shippo doesn’t support
- You need pickup scheduling — automated daily or on-demand pickups across UPS, FedEx, Purolator
- You want to eliminate per-label fees — at 10,000+ labels/month, Shippo’s pricing adds up; a custom platform has zero per-label overhead
- You serve your own clients — 3PLs, marketplaces, and logistics companies need white-label shipping under their own brand
- You need regional or niche carriers — carriers not supported by Shippo (e.g., local couriers, freight)
- You need full data control — compliance, privacy, or regulatory requirements that prevent using a third-party SaaS
A hybrid approach also works: use a carrier aggregator like EasyPost or Flagship for initial carrier coverage while building proprietary value (custom dashboard, analytics, pricing engine) on top.
How ZyroByte Builds Custom Shipping Platforms
At ZyroByte, we design and build custom shipping platforms for logistics companies, 3PLs, eCommerce businesses, and SaaS providers. Our shipping platform work includes:
- Carrier integrations — FedEx, UPS, DHL, Canada Post, Purolator, USPS, and regional carriers
- Rate shopping engines — real-time multi-carrier rate comparison with custom pricing rules
- Label and tracking systems — PDF/ZPL generation, batch processing, normalized tracking
- Merchant dashboards — shipment management, analytics, and carrier configuration
- Pickup scheduling — automated carrier pickup requests
- White-label APIs — ship under your brand, serve your own clients
We’ve built shipping infrastructure that processes thousands of shipments daily, with direct carrier integrations that bypass third-party aggregator fees.
Ready to build your shipping platform? Contact ZyroByte to scope your carrier integrations, architecture, and development roadmap.
Frequently Asked Questions
How much does it cost to build a shipping platform like Shippo?
An MVP with 2–3 carrier integrations, rate shopping, label generation, and a basic dashboard typically requires 8–12 weeks of development. Total cost depends on team size and complexity, but ranges from $30,000 to $80,000 for the MVP phase. Full-featured platforms with 5+ carriers, tracking, webhooks, billing, and analytics cost $100,000–$250,000+.
Which carriers should I integrate first?
Start with the carriers your target market uses most. For North America: UPS, FedEx, and USPS (or Canada Post for Canadian merchants). For international: add DHL Express. You can expand to regional and niche carriers in later phases.
Can I use Shippo’s API as a starting point and customize on top?
Yes. A hybrid approach uses Shippo (or EasyPost/Flagship) as the carrier gateway while you build your own dashboard, pricing engine, and analytics. This accelerates time-to-market but introduces per-label fees and dependency on a third party.
Does Shippo support pickup scheduling?
Shippo supports pickup scheduling for USPS and DHL Express through their web app, but not for UPS, FedEx, or most other carriers via API. If pickup scheduling is critical to your workflow, building a custom integration is the better approach.
What programming language should I use?
For performance-critical components (rate engine, carrier gateway), Go or Rust are ideal. For the dashboard and billing layer, Node.js, Python, or TypeScript work well. Use PostgreSQL for data and Redis for caching.