E-commerce platforms face a familiar problem: payment processing. Most solutions only accept credit cards. This limits the market, especially in regions where traditional banking is unreliable. Cryptocurrency payments offer an alternative, but integrating them is complex.
In 2020, our university software development course gave us a chance to tackle this problem. We had to build a complete e-commerce platform from scratch. I led the technical team and handled the design. My main responsibility was connecting the platform to external services.
Venezuela’s economic situation made cryptocurrency payments relevant. People needed alternatives to local currency. An e-commerce platform accepting crypto could serve a real need.
What Buhocenter Does
Buhocenter is a full-featured e-commerce platform. Customers browse products organized into categories. They add items to their cart. They check out using cryptocurrency.
The platform supports user registration through email, Google, or Facebook. Once registered, users manage their profiles and shipping addresses. The address system only supports US locations, validated through a third-party API.
On the admin side, managers control the product catalog. They add new products, update inventory, and set minimum stock levels. The system tracks which items are running low.
Email notifications keep users informed. Welcome emails go out on registration. Confirmations arrive after purchases. Marketing emails promote new offers and discounts.
Technical Architecture
The application splits into frontend and backend codebases. Both use TypeScript throughout.
The frontend runs on Vue.js 2. It handles routing, state management with Vuex, and internationalization. Users can switch between languages without reloading the page.
The backend uses NestJS, a Node.js framework. It provides a structured way to build APIs with decorators and dependency injection. PostgreSQL stores all the data.
This separation made team collaboration easier. Frontend developers worked independently from backend developers. The API contract served as the boundary.
Module Structure
The backend organizes code into focused modules. Each module handles a specific domain:
- Users and authentication
- Products and catalogs
- Shopping carts
- Payments and transactions
- Addresses
- Notifications
- Third-party integrations
NestJS modules encapsulate related functionality. Controllers handle HTTP requests. Services contain business logic. Repositories manage database operations. This layered approach kept the codebase maintainable as it grew.
Authentication with Firebase
User authentication goes through Firebase Auth. This handles the complexity of social login. Users click a button, authenticate with Google or Facebook, and receive a token. The backend verifies this token on each request.
Traditional email registration also works. Firebase manages password hashing, email verification, and account recovery. We did not have to implement any of this ourselves.
The frontend stores the authentication token. It attaches the token to API requests. The backend middleware validates tokens before processing requests.
Cryptocurrency Payments
The payment system uses the UTRUST gateway. This lets customers pay with various cryptocurrencies. The checkout flow redirects users to UTRUST where they complete payment. Webhooks notify the backend when transactions complete.
I designed the payment module using the strategy pattern. Different payment methods share a common interface. The cryptocurrency strategy handles UTRUST integration. This made it easy to add other payment methods later.
The flow works like this: user confirms cart, backend creates an order, UTRUST returns a payment URL, user pays, webhook confirms, order status updates. Each step has error handling and logging.
Address Validation
Shipping addresses need validation. Invalid addresses cause failed deliveries and frustrated customers. We integrated SmartyStreets for US address verification.
When users enter an address, the backend sends it to SmartyStreets. The API returns a standardized version with postal codes and location data. If the address cannot be verified, the user sees an error message.
This validation happens before saving. Users cannot add invalid addresses to their account. This prevents problems downstream in the shipping process.
The Frontend Experience
The Vue.js application provides a responsive interface. Product cards show images, prices, and availability. Clicking a card opens the full product page with details and reviews.
The shopping cart persists across sessions. Users can add items, adjust quantities, and remove products. The cart shows a running total and applies any available discounts.
Vuex manages global state. User data, cart contents, and product catalogs live in the store. Components subscribe to changes and update automatically. This kept the UI consistent across views.
Internationalization supports multiple languages. All visible text comes from translation files. Switching languages updates the entire interface without page reload. This made the platform accessible to a broader audience.
Team Leadership
As tech lead, I made architectural decisions and reviewed code from the team. I chose NestJS because it enforced structure. Junior developers could follow patterns rather than inventing their own approaches.
Code reviews caught issues early. I looked for security problems, performance concerns, and maintainability. The goal was teaching the team to write better code over time.
Third-party integrations were my direct responsibility. I wrote the Firebase authentication, SmartyStreets validation, and UTRUST payment code. These touched external systems and needed careful error handling.
Challenges We Faced
Cryptocurrency payment testing was difficult. UTRUST sandbox mode did not perfectly match production. Some edge cases only appeared with real transactions. We had to be extra careful with error handling.
Team coordination took effort. Different skill levels meant different speeds. Some features finished quickly while others lagged. I had to balance helping struggling teammates with my own work.
Database migrations caused headaches. TypeORM could generate schema changes automatically. But automatic migrations sometimes made unexpected changes. We learned to review every migration carefully.
What I Learned
This project taught me how to lead a technical team. Writing code is different from guiding others to write code. Clear communication mattered more than technical brilliance.
Third-party integrations require defensive programming. External services fail, return unexpected data, or change without notice. Every integration needs timeouts, retries, and fallback behavior.
Building a complete e-commerce platform revealed the complexity behind simple shopping experiences. User accounts, product catalogs, carts, payments, addresses, notifications. Each piece is simple alone. Together, they form a complex system.
The experience prepared me for professional work. Real software involves teams, deadlines, and integration challenges. Building Buhocenter gave me a preview of that reality.
If you are building e-commerce solutions or working with payment integrations, I would be happy to discuss approaches.
