Case studies

What we built, who it was for and what changed

The warehouses of an industrial multinational, a travel agency, a network of universities, a public university. Every case tells the same story in the same order: what was getting in the client's way, what we built and what was left running. Written for the person who decides, not the person who codes.

Cliente confidencialManufacturing · Logistics

A production WMS for 2 warehouses of an industrial multinational

We designed and launched a warehouse management system that moves ~50,000 units a week, then extended it into an ERP for manufacturing.

The challenge

An industrial multinational needed end-to-end control of its warehouse operation: receive goods with or without an advance shipping notice, put them away, pick orders and know at any moment what is where. All of it fully traceable and run from the floor on handheld devices, with data migrated from the previous system without stopping operations.

How we did it

We started on the warehouse floor, not in an office. We went to see how a pallet is actually received, where picking gets stuck and what a supervisor needs when something does not add up. With that we designed the system around how the floor crew works, and delivered it in parts: every piece was tried with real data before it went live, so nobody had to stop the warehouse.

What we delivered

  • Receiving with or without advance notice from the supplier, pallets with their own label and directed putaway: the system says where each one goes.
  • Picking along the shortest route, shipping, and cycle and full counts with variance approval.
  • Operation from Zebra handhelds on the floor, with scanning and label printing.
  • A movement ledger where every entry and exit is recorded, with corrections and reversals only a supervisor can make.
  • A self-service portal where suppliers and customers submit their shipping notices without calling anyone.
  • Migration of the data from the previous system without stopping the operation.

Outcome

The system runs today in 2 warehouses, moving ~50,000 units a week for ~150 users across operators, suppliers and customers. The same platform is now being extended to a manufacturing client with quotes, sales, invoicing, procurement and a customer portal. Under a confidentiality agreement, we do not publish the name of the client.

Car rental

Four fleet providers, one booking API

We built the booking service of a car-rental platform that unifies four providers with different protocols, with automatic reconciliation and observability on AWS.

The challenge

A rental company working with several fleet providers has the same problem four times over. Each provider publishes its own interface, with its own date format, its own way of naming a car and its own list of errors. If that leaks into the application as is, every screen ends up knowing about providers, and every new provider means touching everything.

How we did it

Each fleet provider had its own system and its own way of talking. Instead of teaching the app four languages, we put a translator in the middle: the app asks for a booking at a branch and the service handles the conversation with whichever provider it belongs to. And before calling anything done, we tested it as if we were the provider: if one of them changes something on their side, we find out in a test, not the customer in a lost sale.

What we delivered

  • A single door to quote, book, look up, modify and cancel, whatever provider sits behind it.
  • If a request arrives twice, it returns the same booking instead of creating another.
  • Automatic detection of bookings left half-done: the provider confirms them but they never got saved on our side. A periodic job finds them and raises a flag.
  • Metrics that tell "found nothing" apart from "could not check", which are not the same thing.
  • Tests against the live provider, behind a switch, with a query cap and without touching anything that costs money.

Outcome

Today the platform sells across all four providers through a single door, and what used to fail in silence now leaves a trace: close to 1,700 automated tests watch every integration, and a booking left half-done is caught on its own instead of showing up as an unexpected charge.

Higher education

We modernized the academic and financial API of a university group

We migrated the 127 endpoints that connect Oracle Banner to Lottus Education's student portals onto a modern architecture, without any consuming system having to change.

The challenge

The service connecting Oracle Banner to student portals and apps had grown for years on a hard-to-maintain foundation. It had almost no automated tests, and its database access saturated during re-enrollment season, exactly when most students use it. It had to be modernized without interrupting payments, re-enrollment or queries, and without forcing consuming systems to change.

How we did it

Before touching anything, we wrote down in detail how the old system answered, odd cases included, so we had something to compare against. Then we replaced it piece by piece, checking each one against the university's system before moving on to the next. And we measured how long each query really took before optimizing, so the effort went only where it would actually show.

What we delivered

  • A new service that answers exactly like the old one on its 127 query points, so no portal had to change.
  • A fast memory for data that does not change often, with different rules during re-enrollment season and an automatic refresh when a payment is recorded.
  • More efficient access to the university's database, so it does not saturate when the most students log in.
  • Better security: passwords and keys kept in a vault, not inside the system.
  • Three cloud environments, development, testing and production, defined as code so they come up identical every time.
  • Automatic deployments that roll back on their own if something fails, and a quality review on every change.

Outcome

The service supports every university in the group, answers queries faster and no longer seizes up at peak season. It went from almost no tests to 322, and every change reaches production through an automated path that can be undone if something goes wrong.

Higher education · Events

A 12-team science rally run from a phone

We built the application that runs UTCJ's Science Rally end to end: judges time each station from their phones, the scoreboard updates instantly on the big screen, and every team sees its route on their own phone.

The challenge

UTCJ runs a rally where 12 student teams rotate through 10 stations across campus, with a judge timing each one. Run by hand, the standings are only known at the end, nobody knows where each team should go next without queues forming, and times taken on ten different stopwatches cannot be defended. The problem to solve was the event's logistics, not just the timing.

How we did it

We started by understanding the event the way the organizer lives it: how many teams, how many stations and what can happen in a round. With that we sketched the three screens, the judge's, the projector's and the teams', before writing any code. Then we built the whole application and rehearsed it with a mock rally, times and penalties included, to see the scoreboard full before event day.

What we delivered

  • Judge panel for phone or tablet: sign in with a PIN, time the trial, add penalties with a reason and see which teams are done.
  • Automatic 12-round rotation that sends each team to a station with no two overlapping, advancing on its own when the round completes.
  • Live screen for the projector: ranking, which team is at which station, running timers and a podium at the end.
  • A view for the teams with an access code: their full route, current round, times and penalties.
  • Time is measured by the server, not the judge's phone, with a cap per station and rules that prevent double starts or two teams at one station.
  • The scoreboard updates itself on every screen, with a fallback in case the campus wifi fails.
  • Results downloadable as a spreadsheet and a panel to make corrections if needed.
  • Everything in a single service, with commands to load the rally, reset it and rehearse it.

Outcome

The rally is run from the judges' phones and followed on the big screen, with the standings updated instantly and final results ready at the close without adding anything by hand. Everything runs as a single service at no infrastructure cost.

Higher education

Self-enrollment: students re-enroll on their own

On top of the cleaned-up connector we built the whole process: students check their eligibility, accept their contract, pay and end up enrolled with a schedule, without going through an administrative window.

The challenge

Re-enrolling meant going to an administrative window. On the software side, the screen was assembled by querying several different services, each with its own format and rules. Adding one validation meant touching several places and trusting that none drifted apart. The goal was twofold: let students do it themselves, and let the front end render the screen in a single call.

How we did it

The delicate part was not the process itself but connecting to the university's academic system, which has been around for years and has its quirks, without inheriting its problems. So the service is suspicious by design: it checks every answer before trusting it, and before charging a student it looks at their real account so nobody gets charged twice, even if someone reloads the page. That caution paid for itself: weeks later something changed in the university's system and the process kept working without anyone touching it.

What we delivered

  • Eligibility in a single query: academic status, student type, balances, holds and prior-level certificate, each block with its reason in plain words.
  • Contract acceptance and the re-enrollment charge posted straight to the student's account.
  • Course enrollment that reports its progress, because the university's system processes it in batches rather than instantly.
  • The student's schedule and its PDF document.
  • Build rules that check themselves on every change, so the system does not get messy over time.
  • Cloud infrastructure defined as code and automatic deployments that roll back if something fails.
  • A guide for the team building the screens, with examples taken from the real system.

Outcome

The full process was proven against the university's live system: the charge is posted, the payment applied, the courses enrolled and the schedule comes out with teacher, day and time. Nothing reaches an environment without passing the 121 automated tests that watch it.

Tell us what is costing you time or money

A 20-minute call with Jesús Hernández or Roberto Urita. You do not need to arrive with everything defined.
No cost, no strings.

Get your free prototype I prefer to write