| Talently | Martín de la flor | Connected | 1 | Yes | 42 | No | — | 30- Alex Montes strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Alex Montes: Thanks for the reminder!
Last project i worked on was a loyalty system for a POS/inventory platform.
The goal was to reward customers for purchases and encourage them to return. The solution was a points-based loyalty system. Merchants could configure how many points customers earned per completed order, for example 1 point or 0.1 per dollar spent, up to them.
The main requirements were:
* Points earning should be configurable by merchant
* Merchants could create rewards
* Rewards could be redeemed using points
* Members could accumulate and spend points
* Every point movement needed to be traceable
For the backend, I used nodejs with TS because the system needed strong typing around transactions, members, rewards, and loyalty operations, but mainly because it was the technologies we(my team) specialized in the last 3 years. The "Decimal" library helped to reduce mistakes in points calculations and redemptions, the number option in nodejs could be risky.
Models for the data:
loyalty-activity-log(new model): to track every points movement. e.g. earning, redemption, or manual adjustment
rewards(new model): the catalog of rewards that could be redeemed with points
shop_configurations(existing model): merchant-level loyalty configuration
members(existing model): new fields for available points, used points, and historical total points
transactions(existing model): new fields for points earned from the transaction and points spent if rewards were applied in this tx
One technical challenge was deciding where to store the “source of truth” for points and therefore if the project should be inside the existing monolith or build a new loyalty service. I decided to keep the full traceability in loyalty-activity-log in the new loyalty service, but also publish(event driven architecture) the events about points changes so the monolith and other services could update its data:
* the members in the monolith would store the calculated balances for fast reads in the POS. This avoided recalculating the full history every time the cashier needed to see a customer’s points.
* the tx in the monolith would store the calculated points earned and points spent if rewards were applied
On the frontend, I used React to build the microfrontend, in this mfe the merchant could manage loyalty configuration and rewards from the admin interface. The UI needed to show current rewards, point costs, and member balances clearly.
let me know if more details are needed Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Alex Montes: The loyalty service I mentionced previoously, I’ve used AWS Lambda mainly for event-driven workflows around business logic processing.
Now, for lambda and S3, I worked in the event log project.
The workflow was the following:
storing: monolith or other service → EventBridge → Firehose(lambda for processing) → S3 Table Bucket
reading: api gw -> lambda -> athena -> s3 table bucket
As mentioned in the workflow, I’ve used AWS Lambda for the processing and S3 to store the data processed.
Now, regarding permissions, I had to create roles for most of this tools, so they have specific access
e.g
the "get events" lambda can just make read queries
the firehose stream can save items in the s3 table bucket
Due to the nature of s3 table buckets, queries can take from 2-10s.
That was ok because the data is massive(events for all changes in the system), but still, we needed to reduce such latency. In order to do that we added a cache layer for most used and recent queries.
Eventbridge helps to scale, also the s3 table bucket was partitioned in such a way it matches our athena queries / use cases , otherwise the request to get the events would time out.
Deployment here was already built. Git actions would trigger the cdk infra. The cdk infra is an in-house project to build and manage all infrastructure of the current repository/service. All changes to the lambdas, services, etc, from the repository would be updated. This happens in every merged PR.
For monitoring, any failure, high latency, api gateway spikes, number of lambdas concurrently working, etc, would send a message to the slack channel "ALERT". Datapoints and thresholds for those alerts depends on the service configuration. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Alex Montes: we can go back to the loyalty service. Ideally, all things related to loyalty should remain in the loyalty service. Nevertheless, to check the user points we would need to create a new model where we store the user id and the current points it has accumulated.
I thought about that at first, but I had to discard this new model in the loyalty service, because a huge part of the frontend would need to change and call the loyalty service to get the current points of the user: the user profile window, user points in the checkout, the checkout would need call the loyalty service to know current user points and if he applies to X reward or not(frontend validation), etc
it was way simpler for the system to get the available points from the existing member endpoint. Integration and updates were way easier. It would ship faster, and that was needed at that moment.
We went down that direction, and it worked out. Data about points was denormalized and shared but the system kept working just fine.
The pain point was frontend/user-flow disruption, not only backend performance.
To measure the success:
- frontend work was reduced drastically
- budtender had available user points wherever the user was already being fetched
- that included the ecom website - Joan Romero
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Joan Romero: A production-grade project I worked on was a multi-tenant education platform built with TypeScript, Next.js, React, Node.js, and NestJS.
Originally, the platform was created for only one client, so a lot of things were designed with single-tenant assumptions: the domain, database relationships, configuration, branding, and even some business logic. The main technical challenge was turning that into a reusable multi-tenant platform without duplicating the codebase.
The hardest part was the architecture. We had to refactor the database so users, roles, groups, courses, permissions, and settings were all connected to the correct tenant. It was not just adding a tenant ID everywhere; we had to make sure the tenant context was part of every important backend flow, because missing that context in a query could create data isolation issues.
On the frontend, we used Next.js to resolve tenant-specific configuration depending on the domain and then render the correct experience for that client. Each tenant could have different branding, feature flags, modules, and settings, but the core React components and business logic were reused. We also had to be careful with caching and server-side rendering, because tenant-specific data should not be cached in a way that could leak into another tenant’s experience.
For the backend, we chose NestJS instead of keeping the API as a simple Express app. The original backend was closer to a single main file with many routes, which was fine early on but became difficult to maintain as the product grew. NestJS gave us modules, controllers, services, guards, interceptors, and dependency injection, so we could separate concerns properly. For example, tenant resolution, authentication, user management, course logic, and configuration management could each live in their own module.
That decision had a big impact. The code became easier to test, easier to extend, and easier for other developers to understand. Express would have given us flexibility, but NestJS gave us structure, and for a multi-tenant platform structure was more important.
The final outcome was very positive. We were able to reuse the same core application and generate client-specific deployments through Vercel, using each tenant’s own domain, environment variables, and configuration. That made onboarding new clients much faster and reduced the risk of maintaining separate versions of the product. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Joan Romero: In one of my last projects, we used AWS Lambda and S3 for the payment and tenant provisioning workflow of a multi-tenant education platform.
The Lambda was triggered after a payment event and worked as a routing layer based on the payment status. If the payment was successful, it started the tenant creation process: first provisioning the deployment and domain configuration through Vercel, and then initializing the tenant’s data in the database. If the payment failed, or if any step failed midway, the Lambda handled rollback logic to avoid leaving incomplete tenants, orphaned domain configurations, or partial database records.
The main scalability decision was keeping the Lambda stateless. It did not depend on local state or hardcoded tenant variables. Everything was resolved dynamically from the payment event, merchant ID, tenant configuration, and database records. That allowed each event to be processed independently, which made the workflow naturally scalable.
We also used S3 for media uploads in a tenant-oriented way. Each merchant had a logical namespace or path structure inside the bucket, so media assets were isolated by tenant. That helped with access control, organization, lifecycle policies, and cleanup if a tenant needed to be removed or migrated.
For security, we used IAM roles with least privilege. The Lambda only had the permissions it needed, such as specific S3 actions, access to required secrets or environment variables, and the necessary network/database permissions. We avoided broad permissions like full S3 or admin access.
For cold starts, we kept the function lightweight. We avoided unnecessary dependencies, kept initialization logic minimal, and separated heavier business logic when possible. Since this was part of a payment-related flow, predictable execution time was important.
Deployment was managed through separate environments like development, staging, and production, with environment-specific variables for Vercel, S3, and database configuration. For monitoring, we used CloudWatch logs and metrics to track executions, duration, errors, and rollback events. We also logged each major step in the workflow, which made it easier to debug tenant creation issues without exposing sensitive payment information.
The final result was a scalable, event-driven workflow where successful payments could automatically provision new tenants, configure deployments, initialize data, and manage media storage without needing a constantly running backend process. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Joan Romero: A specific example was when a user and business pain point forced us to pivot the architecture of a single-tenant education platform into a multi-tenant model.
The pain point was onboarding. Each new client needed their own branding, domain, permissions, user groups, and initial configuration, but the original platform was not designed for that. A lot of the setup was manual or tightly coupled to the first client. That meant onboarding was slow, error-prone, and hard to scale.
The ideal technical solution would have been a full rewrite: redesign the database schema, authentication flow, tenant isolation strategy, deployment model, and configuration system from zero. But the necessary user solution was different. We needed to support new clients quickly while keeping the existing client stable.
So we chose an incremental architectural pivot. We introduced tenant isolation at the data layer, centralized tenant resolution in the backend, and moved client-specific behavior into configuration instead of code. On the frontend, we reused the same Next.js/React core, but loaded tenant-specific branding, feature flags, and settings based on the domain.
That decision was harder than a rewrite in some ways because we had to migrate carefully, avoid regressions, and make sure no tenant-specific data leaked between clients. We had to be very intentional with database relationships, request context, SSR behavior, and caching.
We measured success through practical indicators: reduced onboarding time, fewer manual configuration steps, fewer tenant setup errors, and the ability to launch new tenants without duplicating the codebase. From the engineering side, success also meant the tenant logic became centralized and easier to maintain.
The result was that the platform could support multiple clients using the same core application, with client-specific deployments and domain configuration through Vercel. So the user pain point pushed us away from the perfect technical plan and toward a solution that delivered value faster while still improving the architecture. - Zaghum Abbas medium fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Zaghum Abbas: Sure Sophie: Can you please share a job description with me Zaghum Abbas: I don't have that specific detail, but the recruiting team can help you with that! Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Zaghum Abbas: Here's what you asking
I built a real-time trading dashboard for a fintech client. I used Next.js with ISR for static pages and React Query for live data that combo kept things fast without overcomplicating it. For state I picked Redux since it was lighter and the team picked it up quickly.
On the backend I chose NestJS over Express because we had a team of four and needed consistent structure. TypeScript end-to-end caught a lot of bugs early. The trickiest part was building a WebSocket gateway that cleaned up ghost subscriptions when clients disconnected that was quietly eating memory until we caught it.
I built a document processing pipeline users uploaded to S3, Lambda parsed and stored results in MongoDB. In production we hit cold starts of 3-4 seconds, so I used Provisioned Concurrency for critical Lambdas and a CloudWatch ping every 5 minutes for the rest.
For scalability I put SQS between S3 and Lambda so upload spikes wouldn't cause throttling. For security, each Lambda had its own IAM role with least-privilege access only, and secrets went through Secrets Manager instead of env variables. Deployed with Serverless Framework and monitored with CloudWatch + X-Ray tracing. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Zaghum Abbas: Honestly, the biggest pivot was with that same fintech dashboard. My 'ideal' technical goal was to push every single price update via WebSockets immediately. I wanted that data to be 100% fresh.
But the user reality was different. Users with older laptops started reporting that the app would lag or even crash during high-volume trading. Basically, I was hitting them with so much data that their browsers couldn't keep up with the re-renders.
The conflict was between technical freshness and actual usability. I had to pivot to a buffered update strategy, where the backend still sent the data, but the frontend only 'flushed' those updates to the UI every 200ms.
It was a tough call because I hated 'slowing down' the data, but it was necessary. Success was clear: memory-related crashes stopped immediately, and our 'active session' time shot up because people could finally leave the app running all day without it freezing their computer. - Andres Felipe Castro Cardona strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Andres Felipe Castro Cardona: In my current role and previous experiences, I have worked with microservices-based architectures using Node.js on the backend and Angular on the frontend, where some services expose endpoints directly to the client while others communicate with each other to handle specific responsibilities such as authentication, transaction history management, and core business logic. On the backend, I have chosen NestJS over Express due to its opinionated framework structure, the use of decorators that improve code organization and readability, and its built-in dependency injection system, which enables a more maintainable, scalable, and testable architecture. Its modular approach has also been key when working in larger teams, allowing clear separation of business domains. On the frontend, using Angular, I have implemented SSR in user-facing applications to improve initial load performance, reduce client-side workload, and enhance SEO and Google indexing; while in other projects, particularly internal applications, SSR was not used since SEO was not a requirement and simplicity and faster development were prioritized. These decisions had a clear business impact: reduced response times and client-side load, improved search engine visibility for public products, better system scalability by enabling independent evolution of services, and faster development and maintenance cycles due to a more structured architecture, ultimately allowing the team to deliver features more quickly with fewer errors. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Andres Felipe Castro Cardona: I have experience implementing serverless workflows using AWS Lambda together with Amazon S3 to process events in an asynchronous and highly scalable way. One specific case involved a file processing system where users uploaded documents to S3, which automatically triggered Lambda functions responsible for validating, transforming, and storing the data in other services. One of the main challenges was handling scalability and cold starts: to mitigate this, I optimized package sizes, reduced unnecessary dependencies, and fine-tuned memory allocation (which also improves CPU performance). For critical functions, I also evaluated the use of provisioned concurrency to reduce latency during peak demand.
From a security perspective, I managed access through well-defined IAM roles, applying the principle of least privilege so each Lambda function only had the exact permissions needed (for example, restricted access to specific S3 buckets or CloudWatch logs). I also used secure environment variables and, when necessary, integrated with services like Secrets Manager.
For deployment, I used infrastructure-as-code tools such as Serverless Framework or AWS SAM, which allowed me to version and automate resource provisioning while ensuring reproducible environments. In terms of monitoring, I implemented centralized logging with CloudWatch, set up alarms to detect errors or unusual latency spikes, and added custom metrics to gain visibility into the processing flow. This enabled quick identification of bottlenecks and ensured system stability in production. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Andres Felipe Castro Cardona: In a previous project, we were working on a platform where users’ main pain point was the slow and unclear experience when querying their transaction history. Searches were taking several seconds, and the data was not easy to filter or interpret. From a technical perspective, the “ideal” solution was to redesign the querying system using an event-driven approach with a dedicated indexing engine (e.g., something like Elasticsearch), which would have required a significant architectural change and considerable implementation time. However, the user need was immediate, so we opted for a more pragmatic approach: we optimized existing database queries (indexes, efficient pagination), introduced caching for critical endpoints, and improved the frontend with progressive filtering and incremental data loading.
The core conflict was choosing between a more robust but time-consuming technical solution versus a faster implementation that directly addressed the user’s pain point. We ultimately prioritized short-term user experience, leaving the larger architectural improvement as a future iteration.
We measured success through concrete metrics: response times were reduced from several seconds to under one second for most queries, there was a noticeable drop in feature abandonment rates, and direct user feedback indicated a much smoother experience. Additionally, support tickets related to this issue decreased significantly, validating the positive impact of the decision from both a technical and business perspective. - Luis Fernando Sanchez Agostini strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Luis Fernando Sanchez Agostini: As a Tech Lead, my core philosophy is that business needs dictate the stack—using the exact right tools for the immediate problem while always anticipating future scale and costs. At Xepelin, I orchestrated a distributed data engine that processed 8 TB of financial data monthly (Stack: Node.js, TypeScript, AWS).
The Strategic Pivot (Lambda to K8s):
We started with AWS Lambda for a fast MVP. But as we hit 8 TB/month, the pay-per-execution costs skyrocketed. Because I designed the functions to be "environment-agnostic," we seamlessly migrated the heavy workloads to workers in Kubernetes (EKS) consuming the same SQS queues. This drastically cut our AWS bill while maintaining elastic scaling.
Simplicity in Monitoring:
For task management and health monitoring, I deployed simple, atomic functions behind AWS API Gateway. I explicitly chose not to use frameworks like Express or NestJS because, for such specific tasks, spinning up a full API was an unnecessary waste of resources and maintenance. The simplest solution that solves the problem is always the best.
esult: A financially optimized, highly reliable system ready for the fintech's hyper-growth.
Let me know if you have any questions about the architecture and I can detail it much better, I can also tell you what the decision-making process was like. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Luis Fernando Sanchez Agostini: Everything was designed using Pulumi as Infrastructure as Code (IaC), allowing us to write the infra in TypeScript and stay within the Node ecosystem.
Here’s how the data flow worked:
Entry Point & Circuit Breaker: We used an API Gateway as the entry point. If a provider was down, the Circuit Breaker stopped the execution immediately to avoid queuing doomed tasks and save compute costs.
Fan-out & Communication (Pub/Sub): All inter-service communication flowed through a central Amazon SNS Topic. Depending on the event type, SNS routed the message to the correct SQS queue (consumed by either a Lambda or a Kubernetes worker). These workers extracted the raw data and uploaded it to Amazon S3. 📡
Mappers: That new S3 file triggered an event. A mapper would read it, standardize it, and upload a normalized JSON back to S3.
Caching & Deduplication: To avoid reprocessing, a Lambda calculated the file's hash and checked it against a DynamoDB table (chosen for its blazing fast I/O). If the document hadn't changed, the flow stopped there.
Fan-in: Finally, a service consolidated the job's final status (successes, failures) for accurate metrics.
Isolated Bulk Insert: We ran bulk inserts into an isolated database managed solely by our team, ensuring we didn't crash the company's core product DB. Then we notified other teams that the data was ready.
Observability:
- Infra: We monitored using CloudWatch, we created dashboards and alerts for different metrics in components such as Lambdas, RDS, ElastiCache, DynamoDB.
- Code: We used Sentry for real-time error tracking and stack traces.
Security & Compliance:
We applied the Principle of Least Privilege with highly granular IAM roles. The entire persistent layer lived in private subnets (VPC) communicating outward via a NAT Gateway. We managed credentials with AWS Secrets Manager and encrypted all data at rest using AWS KMS. Zero hardcoded secrets.
Total Isolation: The entire ecosystem ran inside a dedicated (surrogate) AWS account managed by my team. This prevented us from hitting the quotas of the main production account and gave us isolated billing. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Luis Fernando Sanchez Agostini: Our "ideal" engineering and risk flow required extracting 3 years of historical financial data before a new client could operate. For massive corporate clients, this took 10+ minutes. Engineering wanted 100% data completeness; Business and UX absolutely needed an onboarding of under 3 minutes to prevent user drop-offs.
The Pivot (Action):
Instead of just throwing expensive compute power at the problem, I collaborated with Risk and Product to negotiate a "Fast Score" using only the last 3 months of data. To make this work, we pivoted the architecture:
• Prioritized Fan-out: We tweaked our Event-Driven Architecture to chunk the data extraction by timeframe.
• Dedicated Infrastructure: We routed the "last 3 months" chunks into high-priority SQS queues consumed by dedicated, fast-scaling Lambdas.
• Streaming over Batching: Instead of waiting for a massive bulk insert, we streamed this prioritized data immediately to the internal DB and synced with Frontend to show progressive loading (a real-time feel).
Measurable Success:
We successfully reduced the wait time to under 3 minutes for 100% of our clients, saving the onboarding UX! All while the remaining heavy lifting (the other 2 years and 9 months of data) processed silently in the background via our Kubernetes workers - MARCOS LEBRON strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? MARCOS LEBRON: One production-grade project I worked on was the modernization of a healthcare prescription platform. The existing system had a legacy frontend and backend, and the goal was to move to a more scalable architecture with a modern frontend, stronger api contracts, better validation, and a foundation that could support multi-tenant usage for doctors, clinics, pharmacies, and administrators. One of the main technical challenges was managing the prescription flow. it was not just a simple form. The user had to select a patient, choose medications, validate prescription rules, attach doctor information, generate a pdf and preserve enough state so the experience felt fast and reliable. I treated that flow almost like a prescription session where the frontend state represented the current draft while the backend remained the source of truth. for State management, I avoided putting everything into a global store. Instead, I separated the state into different layers. Local ui state stayed inside components, form state was handled closer to the form layer and server state was handled through api driven data fetching patterns. The idea was to avoid a giant global state object that becomes hard to maintain. For shared domain state, like the selected tenant or authenticated user context, I kept that at a higher level because many modules needed access to it. On the rendering side, Next.js was useful because not every page needed the same strategy. Public or semi-static content could benefit from server rendering or static generation, while authenticated areas were more dynamic and API-driven. For example, dashboard and prescription flows needed fresh data and authorization checks, while informational pages or configuration-driven views could be optimized differently. Another feature related to the backend was BFF for different microfrontend applications that I needed to structure. For backend architecture, if I had to choose between NestJS and Express in a similar production-grade environment, I would choose based on the size and complexity. Express is great when you need something lightweight. But if the API has multiple modules, validation rules, authentication, role-based access, and many developers working on it, I prefer NestJS because it gives you a stronger structure through modules, dependency injection, DTOs, guards, and interceptors. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? MARCOS LEBRON: I have experience working with AWS services like S3 and ECS, and also using Lambda and s3 for asynchronous processing. I implemented a file processiong pipeline. The user uploaded the file to s3 and then that s3 event triggered a lambda function. The lambda then validates the file, extracts metadata, transform it. the reason I like this aproach is that it keeps heavy work out of the main api requests. Instead of making the user wait while the backend processes the file, the api can upload a presigned url, store the file in s3 and let Lambda handle the processing in the background. For a cold start, I keep the lambda package small and avoid unnecessary dependencies. I prefer node or python runtimes is faster compared to java or c#. For security i applied least privilege if a function only reads from one S3 bucket, the policy should be scoped to that specific ARN nothing bigger than that, use aws secrets manager for credentials. for deployment i prefer to use CI CD and IAC, that could be SAM, serverless framework, or Terraform. The important thing is that lambda, events, IAM roles and env variables are defined in code and deployed constantly. for monitoring i use cloudwatch for logs and metrics, set alarms and deade letter queue so events are not lost. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? MARCOS LEBRON: A good example was a time at epam where i worked on a large enterprise frontend ecosystem with React, typescript, microfrontend, shared ui libraries, and bff layer. the user pain point was coming from both developers and product teams. we had around 25 applications, and teams were struggling with inconsistent frontend patterns, duplicated logic, slow local builds and repeated APO transformations logic across different microfrontends. So features took longer to deliver small ui changes required more coordination than they should, and onboarding new devs was slow, The ideal technical solution would probably have been to redesign the whole platform from scratch and make every application follow the same perfect architecture. But that was not realistic because these were production apps, teams were actively delivering features, and we could not pause the business to do a full rewrite. The difficult part was balancing technical idealism with what users actually needed. As engineers, we often want the cleanest possible architecture, but the users need faster builds, more consistency, and less friction immediately. So we chose an incremental migration instead of a risky full rewrite. so we made a more pragmatic architectural decision. Instead of trying to fix everything at once, we focused on the biggest pain points. We migrated the build system from Webpack to Vite, improved the shared UI libraries, and used the BFF layer to simplify how the frontend consumed backend data. We measured success with both technical and practical signals. The biggest concrete metric was that the Vite migration reduced build times by more than 50%. We also saw better developer experience, faster local feedback loops, more reuse from shared packages, and cleaner integration through the BFF.
The takeaway for me was that architecture should solve real pain. In this case, the right decision was not to chase a perfect rewrite, but to make targeted architectural changes that improved delivery speed and system consistency while keeping production stable. - Andres Rocha
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Andres Rocha: Sure, one project that comes to mind is an investment design platform I worked on, where users could build and simulate capitalization tables in real time. Sounds straightforward until you factor in that every single input change needs to cascade instantly — dilution percentages, valuations, equity breakdowns — all live, all consistent across multiple investor profiles simultaneously. That was the real challenge.
The core problem was state management. Cap tables are inherently interdependent, so a change in one cell isn't isolated — it triggers a chain of recalculations. We couldn't let the UI ever show a half-updated state, and we couldn't afford race conditions during simulation runs either. The solution was splitting the workload: heavy financial calculations went through RabbitMQ as background jobs, while the UI stayed responsive through optimistic updates and WebSocket-pushed confirmations. That separation of concerns was what kept the system from becoming a nightmare to reason about.
On the backend, we evaluated Express versus NestJS, and the arguments for NestJS were pretty clear once we mapped out the requirements. Express gives you freedom, but on a financial platform with a larger team, that freedom tends to become inconsistency over time — everyone structures their modules differently, dependency management gets messy, and testing becomes painful. NestJS forces a modular, DI-based architecture from day one. That structure was worth more than any flexibility we were giving up.
The TypeScript integration was another big factor. We were using strictly typed DTOs for every calculation service, and that caught a surprising number of potential bugs before they ever hit runtime. For financial logic, that's not a nice-to-have — it's a requirement. We also got clean patterns for the RabbitMQ microservice integration and WebSocket handling out of the box, rather than wiring all of that manually.
In practice, we reduced boilerplate by around 30%, test coverage improved significantly, and the frontend team could mock services without needing to coordinate with us constantly — which made a real difference in sprint velocity.
On the frontend, we used Next.js with ISR for the dashboard layer. Investment templates don't change by the second — they're read-heavy but do get updated periodically. ISR was the right fit: pages are pre-rendered statically, but when a user pushes an update, it propagates globally without a full rebuild. We kept LCP under 1.5s even on views with dense data visualizations, which was one of our harder non-functional requirements to hit. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Andres Rocha: Most of my hands-on Lambda and S3 experience comes from my time at Konfio, where we ran a fairly large AWS-based architecture handling payment orders, KYC flows, and document processing across multiple microservices.
A concrete case where scalability became a real concern was around document ingestion in the KYC platform. We had periods where a high volume of users were uploading identity documents simultaneously — images, PDFs, that kind of thing. The initial approach of routing uploads through the Lambda directly became a bottleneck fast: the function was handling both the HTTP layer and the S3 write, which under load created timeouts and inconsistent responses. The fix was straightforward once we identified it — we moved to presigned URLs, so the Lambda's only job was generating a short-lived, scoped URL that the client used to upload directly to S3. That decoupled the load from the function entirely and let S3 handle the ingestion at its own scale, which it does well.
On cold starts — this was something we had to think about carefully for Lambdas that sat in critical paths, like the ones triggering downstream processes after a document was validated. Cold start latency in those cases was noticeable. The approach we settled on was Provisioned Concurrency for the functions that needed to respond fast, keeping a set number of instances warm at all times. For less critical functions, we used scheduled EventBridge rules as a lighter alternative — just enough to keep them from going completely cold during business hours. The tradeoff with Provisioned Concurrency is cost, so we were selective about where we applied it.
For IAM, the rule we followed was strict least-privilege per function. Each Lambda had its own role scoped to exactly what it needed — if a function's job was to read from a specific S3 bucket, its role only allowed s3:GetObject on that bucket's ARN, nothing broader. This mattered especially in a fintech environment where a misconfigured or accidentally triggered function shouldn't be able to touch data it has no business accessing. We also used resource-based policies on the S3 side to add a second layer — so even if a role was misconfigured, the bucket itself would reject unauthorized actions.
Deployment was managed through Terraform for infrastructure definitions and CodePipeline for the CI/CD side. Lambda configurations, IAM roles, S3 bucket policies — all version-controlled and applied through the pipeline, which made environment parity between staging and production much easier to maintain.
For monitoring, CloudWatch was the primary tool — we had log groups per function, metric filters for error rates and duration, and dashboards aggregating the most critical functions. For anything that needed deeper tracing across services, we used X-Ray to follow a request through the chain and identify where latency or failures were actually happening. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Andres Rocha: This one comes directly from the KYC platform at Konfio, and it's a good example of how skipping proper discovery with the actual end user can force a significant architectural rework down the line.
The platform was originally built to support a document review flow for internal KYC analysts — the people responsible for validating loan applications. The initial design was straightforward: reviewers could see the most recent document uploaded by the applicant for each required field. That seemed reasonable at the time, but it turned out to be a critical gap.
As the volume of applications grew, the team started flagging an unusual number of false rejections. Analysts were rejecting applications that should have been approved, and when we dug into the cases, a pattern emerged. Applicants would upload a document, it would get flagged for some reason — expired ID, wrong format, incomplete information — and they'd upload a new version. But the reviewer had no visibility into the previous submissions. They couldn't tell whether the issue had actually been corrected or whether the new document introduced a different problem. Without that context, decisions were being made on incomplete information.
There was also a separate but related problem we uncovered during the same investigation. Sales reps, who were often sitting with applicants during the onboarding process, were sometimes uploading documents from their own accounts or pushing files through unofficial channels when something wasn't going through correctly. That was generating file inconsistencies on the platform side and bypassing the validation pipeline entirely. That category alone accounted for roughly 40% of rejection errors across all applications.
The conflict was architectural. The system had been designed around a single-document-per-requirement model — there was no concept of document history or versioning at the data level. To fix this properly, we needed to restructure how documents were associated with applications: instead of a flat reference to the latest file, we needed a versioned relationship between each document type and all its submissions across the lifecycle of a request. That change wasn't isolated — it touched the storage layer, the review UI, the validation logic, and several downstream processes that consumed document state.
The decision to do it properly rather than patch around it was driven by the KYC team themselves. Once we sat down with the analysts and mapped out how they actually worked through a review — what information they needed, what context they were missing — it became clear that a surface-level fix wouldn't hold. We needed to give them a tool that matched their actual workflow.
We measured the outcome mostly through rejection error rates. False positives dropped significantly once reviewers had full document history available. The sales rep workaround problem was addressed through stricter upload attribution and validation at the point of submission, which closed that gap at the source. The broader result was a faster, more confident review process — fewer escalations, less back-and-forth with applicants, and a meaningful reduction in the time vendors were spending re-collecting documents that had already been submitted correctly. - Fabricio Bencomo strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Fabricio Bencomo: When I worked on that e-commerce app, we used React Native for the mobile side and NestJS for the backend. At first, we thought about using Express is simple, but we ended up choosing NestJS instead. It was a smart move because NestJS already has everything built-in, like data validation and security roles. If we had used Express, I would have spent way too much time adding all those features manually, which usually makes the code a bit of a mess. Using decorators in NestJS just made everything much cleaner and easier to manage.
The most difficult part of the project was definitely the shopping cart. I really wanted the app to feel fast and smooth, so I tried to avoid those annoying loading screens as much as possible. However, we still had to make sure the prices and stock levels were 100% accurate from the server. To solve this, I used two different methods. When someone added a new product, I made the app wait for the server to confirm it first. But for changing quantities or removing items, I made the UI update instantly. The app would sync with the database in the background, and if there was ever an error, it would just "roll back" to the previous state.
I also had to figure out how to share information between the cart and the user's login details. I used Zustand for state management, which turned out to be a great choice because it's very straightforward to let different parts of the app talk to each other. For security, I set up authentication using JWT tokens and added SMS verification with Twilio. To keep everything safe, I made sure all the tokens were encrypted before saving them on the phone. By the end of the project, we had a really solid architecture that was easy to scale without breaking things. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Fabricio Bencomo: One of the most specific workflows I implemented was the image processing pipeline for our products. When an admin uploaded a photo, we couldn't block the request while waiting for the image to be resized and optimized. That had to happen in the background. The solution was using S3 triggers: the image was uploaded to a raw bucket, and that automatically started a Lambda function that processed the file and saved the result in a second bucket for mobile images.
Security was a priority from the start. That Lambda had no reason to touch the database or read other buckets, so I gave it an IAM role with minimum permissions. It could only read from the source and write to the destination. This is important because if the function was ever compromised, the damage would be completely limited.
I also had to fix a problem with cold starts. NestJS initializes many dependencies at the start, which added about 800ms of delay. I solved this by putting the dependencies in a Lambda Layer to make the package smaller. I also reused the application instance between calls and used Provisioned Concurrency for the inventory search, because that is where users really noticed the lag.
For deployment, I used GitHub Actions. Every time we merged to main, it compiled the project, organized the layers, and deployed using the Serverless Framework. Everything was automated without any manual steps. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Fabricio Bencomo: While testing our auto parts platform, we ran into a really annoying issue where cart totals were shifting or showing up as zero at checkout. This was especially common for people on older Android phones or spotty connections, affecting about 20% of those users.
The textbook fix is usually to update the UI instantly and sync in the background, but our prices fluctuated too much for that. A 60 second lag on a slow connection meant the price the user saw could be outdated by the time they hit the button. To fix this, we split the logic. We made the app wait for the server when adding new items to ensure the price was dead accurate, but kept things instant when just changing quantities or deleting items since the price stayed the same.
We also caught a bug where bad connections sent back empty price data, so we wrote a special function to catch and repair those errors on the fly. It made the code a bit more complex, but we chose user trust over having a perfectly symmetrical architecture.
The results were great. Errors in the final total dropped from 18% to zero, and about 40% fewer people abandoned their carts. If I did it over, I would probably use something like Redis to speed up those server checks. That way, we could keep the data 100% accurate without making the user wait at all. - Libardo Andres López Cala strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Libardo Andres López Cala: I worked on a production e-commerce platform using TypeScript, Node.js (Express), and modern frontend frameworks. A key challenge was performance in the product and checkout flow due to multiple integrations (SAP, payments, inventory).
To solve this, we redesigned the backend as an orchestration layer, creating aggregated endpoints instead of multiple frontend calls. This reduced latency and simplified the frontend.
We chose Express for its flexibility and low overhead, allowing fast iteration and custom middleware. However, for long-term scalability, NestJS would have been a better choice due to its modular architecture and built-in dependency injection.
On the frontend (in a Next.js scenario), I would use SSR for dynamic/SEO-critical pages and ISR for catalog pages to balance freshness and performance. For state management, I prefer server-state tools like React Query over heavy global state.
The result was improved response times, better maintainability, and a cleaner separation between frontend and backend. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Libardo Andres López Cala: My direct serverless experience is mainly with AWS S3 in production, where I implemented secure file uploads using pre-signed URLs. This improved scalability by offloading heavy file handling from the backend.
While I haven’t used Lambda extensively in production, I’m familiar with event-driven patterns like triggering functions from S3 for file processing. I understand key challenges like cold starts and would mitigate them by keeping functions lightweight and using provisioned concurrency when needed.
On security, I’ve worked with IAM principles, applying least-privilege access and avoiding credential exposure. For monitoring and deployment, I’m comfortable with CloudWatch and CI/CD pipelines.
Overall, I have a solid foundation in serverless concepts and can ramp up quickly in Lambda-based architectures. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Libardo Andres López Cala: In an e-commerce project, users experienced slow checkout times due to multiple backend calls (SAP, inventory, pricing).
The “ideal” solution was to keep a clean microservices approach with independent calls, but this created latency and a poor user experience. The “necessary” solution was to pivot to a backend orchestration layer, aggregating data into a single optimized endpoint.
This reduced frontend complexity and significantly improved response times, even though it introduced tighter coupling in the backend.
We measured success through reduced checkout latency, fewer user drop-offs, and improved conversion rates. The key takeaway was prioritizing user experience over architectural purity when needed. - Sergio Matamoros strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Sergio Matamoros: Developing the Ariel Scheduling System required a robust architecture using NestJS for a modular, type-safe backend and Next.js to leverage Incremental Static Regeneration for optimal performance. The core technical challenge involved managing real-time booking synchronization to prevent race conditions, which I solved by implementing optimistic updates via TanStack Query and WebSockets for immediate feedback and data integrity. This choice of a structured framework over a more minimal approach like Express allowed for seamless validation through DTOs and a scalable codebase that maintained high speed and reliability even as complex features like inventory management were integrated. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Sergio Matamoros: I have implemented serverless workflows using AWS Lambda and S3 to automate high-volume data processing, specifically for managing dynamic assets and inventory updates in a production environment. To address the challenge of cold starts, I optimized the execution environment by minimizing the deployment package size and utilizing Provisioned Concurrency for time-sensitive triggers, ensuring the system remained responsive during sudden traffic spikes. Scalability was managed through S3 event notifications that triggered Lambda functions asynchronously, while security was strictly enforced using the principle of least privilege with granular IAM roles, limiting function access only to the specific S3 prefixes and database rows required for the task. For deployment and monitoring, I utilized the AWS Serverless Application Model (SAM) alongside CloudWatch for real-time logging and performance metrics, allowing me to track execution duration and memory usage to ensure the workflow remained cost-effective and resilient under heavy loads. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Sergio Matamoros: While developing the Ariel Scheduling System, a significant user pain point emerged when clients in areas with unstable internet connectivity reported that the application would freeze or lose booking data during brief signal drops, leading to a "necessary" pivot toward a robust offline-first synchronization strategy. The "ideal" technical solution from a developer's perspective was a strictly server-authoritative model that ensured absolute data consistency by requiring a constant connection, but the "necessary" user solution demanded that the interface remain interactive even when offline. This forced an architectural shift to implement a local-first state using IndexedDB through TanStack Query's persistent cache, allowing users to continue the booking flow while the application queued requests locally. The conflict was resolved by creating a synchronization engine that handled background reconciliation once the connection was restored, prioritizing the user's intent over immediate server confirmation. Success was measured by a 35% decrease in abandoned booking sessions and a significant drop in support tickets related to "lost data," proving that sacrificing a purely synchronous architecture for a more resilient, client-side caching model was essential for real-world usability in the technician's specific operating environment. - Sebastián Josué Montero Madrigal strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Sebastián Josué Montero Madrigal: while my strongest production experience has been backend-focused, i've been applying full stack principles using TypeScript, React, and Node.js concepts
i built a REST API whit ASP.NET Core for managing a motorcycle inventory system, using a layered architecture with controllers, services, and data access A key challenge was maintaining scalability and clean separation of concerns, which i solved by isolating business logic in a service layer and using dependency injection this is why i would choose NestJS over Express in Node.js, since it enforces a similar structured approach
On the frontend side I've worked whit React focusing on state managmente and component design, ensuring efficient data flow and avoiding unnecessary re-renders
Regarding Next.js i understand trade-offs like SSR vs ISR for frequently changing data, such as inventory status i would use SSR for consistency while ISR would be useful for less dynamic content to improve preformance
overall i bring strong backend fundamentals and a growing practiacl undestanding of full stack development especially around architecture and data flow Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Sebastián Josué Montero Madrigal: i haven't yet implemented a full production workflow using AWS lambda and S3, but i have studied and practiced serverless architecture concepts and how they apply to scalable systems
from my backend experience building REST APIs, i understand how to desing stateless services, which translates well to Lambda functions, for example in a system like my motorcycle inventory API, i would use Lambda to handle event-driven tasks such as processing updates or handling file uploads whit S3 used for storage
regarding scalability one advantage of Lambda is it automatic scaling but im aware of challenges like cold starts to mitigate this i would minimize function size, reduce dependencies and consider strategies like keeping functions warm for latency-sensitive operations
for security i undestand the importance of IAM roles and least-privilege access, each Lambda function should only have permissions strictly necessary, for example limited access to specific S3 buckets or actions
for deplayment and monitoring i'm familiar with tools like AWS SAM or Serverless Framework for structured deployments, and CloudWatch for logging and performance monitoring, even though i'm still building hands-on experience with these tools, i have a solid understanding of how to apply them in real scenarios
overall while my direct production experience whit AWS serverless is still growing, i have a strong foundation in backend architecture and i'm actively working on applying these concepts in could enviroments Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Sebastián Josué Montero Madrigal: in one of my backend projects i built a motorcycle inventory system where users needed to quickly view and update vehicle availability, initially i designed the system with a more "ideal" architecture-strict separation of layers normalized data structures, and multiple relational joins to ensure consistency and scalability
however during testing i realized this approach introduced latency when retrieving data, especially for common user actions like listing available vehicles from a technical perspective, the design was clean and correct, but it didn't provide the responsiveness users needed
the pivot was to optimize for the user experience rather than strict architectural purity, i introduced more efficient queries and simplified some data access patterns, even if that meant slightly relaxing normalization in certain areas this reduced response times significantly and made the system feel much more responsive
the main conflict was betwwen maintraining a perfectly structured, theoretically ideal backend versus delivering fast, practical performance for end users, i chose to prioritize the user experience ehile still keeping the system maintainable
to measure success i compared response times before and after the changes and validated that common operations became noticeably faster, additionally the system handled frequent queries more efficiently without affcting stability
this experience reinforced the importance of balancing clean architecture with real world user needs, especially in performance-sensitive applications - José Torres strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? José Torres: For a recent high-demand project (called Project Windfall), I set up a monorepo with Turborepo using Next.js and NestJS. I chose the NestJS library over Express for the backend because, since it’s a system with complex business logic, I needed a modular and robust architecture that would facilitate dependency injection and long-term maintenance, avoiding the clutter that often arises in Express as the project scales.
The biggest challenge was managing real-time state for thousands of concurrent users. To avoid compromising performance, I separated the logic: I used TanStack Query for server-side caching and Zustand for atomic global state. This, combined with a Redis layer on the backend and database index optimization, reduced response latency from 500 ms to less than 100 ms, enabling smooth updates without unnecessary re-renders.
I used TypeScript to share data models between the backend and frontend within the monorepo, achieving end-to-end type safety, which virtually eliminated all integration errors. Ultimately, these decisions enabled the platform to handle critical traffic spikes while continuing to deliver a robust user experience. I employed the modular atomic design methodology to make the components more modular and scalable. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? José Torres: I've implemented serverless workflows using S3 as a trigger for AWS Lambda functions dedicated to file processing and data extraction. To handle scalability and prevent bottlenecks, I used Amazon SQS as a buffer, allowing the system to process load spikes asynchronously without hitting concurrency limits. Regarding cold starts, I optimized performance by reducing bundle sizes with esbuild and applying Provisioned Concurrency to business-critical processes.
For security, I strictly follow the principle of least privilege using specific IAM Roles, limiting Lambda access to exact S3 buckets and prefixes. I manage deployment and monitoring through Infrastructure as Code (IaC) with the Serverless Framework integrated into GitHub Actions pipelines, while centralizing observability via CloudWatch and AWS X-Ray. This approach ensures an auditable, secure, and highly scalable environment that aligns perfectly with project operational costs. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? José Torres: In a project for an online casino, we faced a conflict between data consistency and perceived performance. The "ideal" technical solution was to validate every action directly with the server to ensure 100% balance accuracy, but this created frustrating latency for users with unstable connections. To address this pain point, we pivoted to an Optimistic UI architecture using Zustand and TanStack Query. This allowed the interface to react instantly (under 100ms) by predicting the success of an action on the client-side, while the actual synchronization happened in the background with a robust rollback system in case of server-side failure.
We measured success through both product metrics and technical performance. We saw a 25% increase in session duration as the visual fluidity eliminated the friction that was causing user drop-off. Technically, we monitored the "rollback rate" to ensure our prediction logic remained accurate and optimized our Interaction to Next Paint (INP), moving from a critical state to "Good" in Core Web Vitals. This pivot proved that prioritizing immediate feedback over absolute synchronous consistency was essential for maintaining user engagement. - Jesus Miguel Agamez Caraballo strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Jesus Miguel Agamez Caraballo: ok Sophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Jesus Miguel Agamez Caraballo: I worked on a financial management platform using Next.js, TypeScript, and Node.js. One of the main challenges was optimizing SSR, since we had highly dynamic pages that were impacting load times. Initially, we used full SSR, but it introduced high latency. We migrated to ISR to cache partially dynamic pages, which reduced TTFB by around 40%.
On the backend, we chose NestJS over Express because we needed a more modular and scalable architecture. NestJS provided dependency injection and better structure, which made it easier to scale the project.
The trade-off was higher initial complexity, but it paid off with better maintainability in the long term. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Jesus Miguel Agamez Caraballo: I implemented a serverless workflow using AWS Lambda and S3 where file uploads triggered Lambdas to process and store data. To handle scalability, Lambda’s auto-scaling worked well, but we optimized memory and execution time to control costs. We reduced cold starts by minimizing bundle size and using provisioned concurrency for critical functions. For security, we applied least-privilege IAM roles so each Lambda only accessed what it needed.
Deployment was managed with the Serverless Framework, and monitoring with CloudWatch logs and alerts.
Overall, it scaled well with low ops overhead, but required careful optimization around cold starts and permissions. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Jesus Miguel Agamez Caraballo: In a financial platform I worked on, users complained about slow page loads when checking their balances and transactions. Technically, the “ideal” solution was to keep everything fully dynamic with SSR to always show real-time data. However, this created high latency and a poor user experience. We made a trade-off by introducing ISR and caching, even though it meant data could be slightly stale for a short period. The conflict was between real-time accuracy (ideal) vs fast and smooth UX (necessary). We prioritized user experience and added manual refresh options for critical actions. To measure success, we tracked TTFB, page load time, and user engagement. After the change, load times improved by ~40% and user drop-off decreased significantly. - pablo guzman strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? pablo guzman: well the most complex project I have work was con travel tourist application I used nest js to configure the api service and I choose it because of bussiness requirement and because nest js offers structure and fast building and scalable structure (dependency injection, DTO´s, ), on the front end site we used next js because the main goal of the prject was to get the max score in SEO also it was the first time I implemented tanstack query and it help to abstract and hanlde better most of the code when dealing with API and cahe and navigation reducing stress on services (DB, http request) Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? pablo guzman: sure I have use AWS just once and most of experience for this kind of deployment is on vercel and railway, in both I had config the server turn off and on if there were no requests in certain period of time, I handle most of my deployment via github and sync it with the services, and the monitoring via the service dashboard Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? pablo guzman: there was a time when our team was asked to deploy a react native app to the ios and android store but it took more time than expected and time was upon us, so the team proposed to implement the app as a Progressive web app (PWA)instead so we got the approval and we were able to deliver this way and forget about ios and android issues for new apps - Johan Marcel Fernández Castillo strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Johan Marcel Fernández Castillo: Sure! I recently led a project where we built a high-performance platform using Next.js, TypeScript, and Tailwind CSS with shadcn/ui.
The main challenge was balancing a rich UI with fast load times. I architected the solution using React Server Components (RSC) for the majority of the application. This significantly improved our SEO and reduced the JavaScript bundle size since most of the logic stayed on the server. I reserved Client Components strictly for interactive elements like complex forms or real-time filters.
For the backed: Next.js API Routes
Instead of a separate Express server, I leveraged Next.js API Routes.
Why: It simplified the architecture and deployment. Since the frontend and backend share the same TypeScript definitions, I ensured full type safety across the entire stack.
This reduced cold start latency and infrastructure costs. By using Server Actions, I eliminated the need for most 'useEffect' data fetching, making the data flow more predictable and much easier to maintain. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Johan Marcel Fernández Castillo: I’ve used AWS Lambda and S3 primarily to build event-driven, asynchronous workflows. I implemented a pipeline where users uploaded large assets to an S3 bucket. This triggered a Lambda function to process the files (optimization and metadata extraction) before updating our database.
To handle spikes in traffic, I optimized the Lambda package size by keeping dependencies minimal, which significantly reduced cold start times. For latency-critical paths, I used Provisioned Concurrency.
I followed the principle of 'least privilege.' Instead of broad permissions, I created specific IAM roles for the Lambda with access only to the necessary S3 prefixes and specific DynamoDB tables.
I managed the infrastructure using AWS SAM to ensure reproducible environments. For monitoring, I relied on CloudWatch Logs and set up Alarms to notify the team of any execution failures or duration timeouts Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Johan Marcel Fernández Castillo: A good example was in an HOS (Hours of Service) system I worked on for a company in the sugar industry.
The ideal technical solution was strict validation on every step driver license checks, freight direction validation, and route confirmation with separate API calls. Architecturally, it was clean, but users hated it because dispatchers needed speed, not extra friction.
The pain point was that operators were losing time with repeated validations, unnecessary re-renders, and form resets.
I changed the flow using React, TypeScript, Apollo Client, and redux-form so validations only happened when values actually changed for example, the driver license endpoint only ran if the license number was modified. I also optimized state handling to avoid unnecessary re-renders and duplicate requests.
The backend team preferred stricter validation, but we prioritized the user experience while keeping critical checks.
We measured success by faster form completion, fewer support complaints, and fewer repeated API calls. The best proof was that users stopped using manual workarounds and trusted the system more - Geovanni Mena
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Geovanni Mena: Happy to. The clearest example is Acatha, an accounting and tax platform serving *8,000+ clients and processing over 6 million transactions*. I built the dashboard in React with TypeScript on top of CoreUI Pro, integrated with a Laravel + PostgreSQL backend on AWS.
The hardest technical challenge was *automating journal entry generation*. The platform handles double-entry bookkeeping at high volume, and every client has a different chart of accounts. I implemented custom algorithms that ingest raw operations and emit valid accounting entries per client, which *cut processing time by 70%*. *TypeScript was non-negotiable here.* When generated entries move real money, having the compiler catch malformed payloads at build time is worth every bit of the upfront cost.
On state management, I *deliberately stayed away from Redux*. The dashboard had clear bounded domains, financial summaries, journal modules, client switching, and Redux would have introduced more boilerplate and global coupling than those domains needed. I built *custom hooks per business concern* and used Context API for cross-cutting state like the active client and session. Each module ended up *independently testable*, bundle size stayed smaller, and new engineers could ship features without learning a global store.
On the backend choice, Acatha runs on Laravel, which *I would defend for a regulated accounting domain*. Eloquent's relationship handling and Laravel's queue and validation ecosystem fit the workload better than rebuilding it in Node would have. When I have reached for Node, my default is *Express for thin, I/O-bound services* where the event loop pays off, and *NestJS when the team is larger and the domain benefits from explicit modules and dependency injection*. *The choice should follow the workload, not the stack.* Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Geovanni Mena: At FacePhi, the closest example is the *fraud investigation pipeline* I built around our biometric image analysis. Client images and analysis artifacts land in S3, S3 events trigger Lambda functions that run metrics extraction, AI-generated content detection, and DeepFake analysis against multiple models, and results land back in S3 and DynamoDB for the CLI tool I wrote in Go to consume. End-to-end, *case analysis dropped from hours to under 5 minutes*.
On *scalability*, the Lambda concurrency model fit the workload because cases arrive in bursts during fraud incidents, not as steady traffic. I sized reserved concurrency to protect downstream model endpoints from being flooded, and pushed long-running analysis into Step Functions when a case needed multiple sequential models. For batch reprocessing, replaying historical cases against new model versions, I used SQS in front of Lambda so we could throttle without dropping events.
On *cold starts*, I split functions by latency budget. Anything user-facing through the CLI got *provisioned concurrency* so the first invocation did not pay the runtime penalty. Background analysis runs were fine to absorb the cold start, so I left those on-demand. Go also helped, sub-100ms cold starts versus 1 to 2 seconds on heavier runtimes.
On *security*, biometric data is regulated, so IAM was tight. *Each Lambda had a dedicated execution role scoped to the exact S3 prefix it owned*, with KMS keys per client tenant so a misrouted function physically could not decrypt another client's images. S3 buckets enforced encryption at rest, blocked public access, and required SigV4 signed URLs for any access from the CLI. Every decrypt operation was logged through CloudTrail.
On *deployment*, infrastructure ran through Terraform with separate workspaces per environment. CI/CD ran in GitHub Actions: linting, unit tests, terraform plan as a PR check, and apply gated on manual approval for production. Lambda code shipped as container images so model dependencies were reproducible.
On *monitoring*, I built CloudWatch dashboards per service tracking invocation count, duration p50/p95/p99, error rate, throttles, and concurrent executions. Custom metrics tracked per-client TPS and analysis latency. This fed into the *real-time SaaS monitoring platform I designed at FacePhi*, which became the company-wide internal support tool across all departments. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Geovanni Mena: At FacePhi, the *support team handling fraud investigations* was the user that drove this. Each case meant pulling biometric images, running them through several detection models for AI-generated content, DeepFake, and image manipulation, comparing results, and writing up findings. A single case *took hours of manual work*, and the team was getting buried as fraud volume grew.
The ideal technical solution was a *full SaaS platform*: multi-user dashboard, drag-and-drop uploads, real-time visualization, role-based access. Probably 4 to 6 months of work plus security review for handling biometric data through a new web surface, plus UX cycles, plus on-call ownership of yet another service.
The necessary solution was a *Go CLI that ran on the support engineers' machines*. They already worked from terminals, already had the credentials, already piped output between scripts. *Meeting them where they were meant the tool could ship in weeks instead of quarters.*
The conflict was real. A CLI is harder to evolve and has no UI for non-technical users. But the support engineer drowning in cases today did not need any of that. They needed to stop reading model outputs by hand.
I measured success on three things. First, *case analysis time dropped from hours to under 5 minutes*. Second, adoption: the support team replaced their manual workflow within weeks. Third, leverage: the same CLI was later extended to batch-reprocess historical cases against new model versions, work that would have been a separate project under the SaaS plan.
The lesson I keep is that *'ideal' is often shorthand for 'optimized for users we don't have yet.'* Building for the user in front of you ships faster and earns the right to build the bigger thing later, if it's still needed. - Eyder Garcia medium fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Eyder Garcia: Well to start to use any of state management correctly I first clarify that the SSR is used for almost all components developments or pages because this is very good and respect best practices to reach out a better performance regardless data retrieved and SEO also its very useful to use ISR in order to keep editing pages or piece of codes without rebuilding the entire page or code.
Regarding Backend Architecture well both depends or scalabily product and also how many teams collaborate with the project. I mean if it means about a product or project that not scale in such a big cases we can start with Monolitich Modular Pattern Architecture since its very clean and more understand for small-medium project and i use Express.js
Now for Nest.js cases I’ll prefer using Microservice Pattern Architecture since the framework its very friendly and stable and provide many resource and its very accesible for this such of thing but again it depends of how many people are collaborated with the project and also if the project its a very scaleable and complexity product and needs to be indenpendently. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Eyder Garcia: About AWS in general i just have knowledge and bit of experience but i’ve use S3, EC2 for personal projects. its not difficult to me to learn new topics or standard I have techniques and skills to adapt and fast learning.
For monitoring i can use the monitorint that provided the AWS platform and also Sentry for backend and frontend. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Eyder Garcia: I can stablish a kind of comparative table to find out the specific each of feature that belongs to each approach and then I analizy by exploring the key differencies, the scope, disadvantages and also make a research using AI and analyze the comparison - ANGEL VILLAVICENCIO strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? ANGEL VILLAVICENCIO: Sure. One of the main projects I worked on was a SaaS marketplace built with TypeScript, Next.js, and Node.js on AWS.
On the frontend, we used SSR and ISR with Next.js to balance performance and dynamic data. A key challenge was handling frequently updated content without losing performance, so we combined ISR with client-side fetching using React Query.
For state management, we avoided Redux and used React Query + local state, which simplified caching and improved performance.
On the backend, we used NestJS for its modular architecture and scalability. The system was deployed on AWS using a serverless approach with Lambda, API Gateway, and S3 for storage. We integrated SQS for async processing (e.g., image handling, notifications) and used RDS with optimized queries for relational data. We also leveraged CloudFront for CDN and improved latency, and implemented infrastructure as code for consistent deployments.
This allowed us to scale efficiently, decouple services, and maintain high performance under increasing load. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? ANGEL VILLAVICENCIO: Sure. I’ve worked extensively with serverless workflows using AWS Lambda and S3 in production environments.
In one project, we built a pipeline for processing user-uploaded images. Files were uploaded to S3, which triggered Lambda functions for validation, transformation, and metadata storage. To handle scalability during peak traffic, we designed the system to be fully event-driven using S3 + SQS, allowing us to buffer and process jobs asynchronously without overloading the system.
To mitigate cold starts, we kept Lambdas lightweight, optimized dependencies, and split functions by responsibility. For critical paths, we also tuned memory allocation to improve execution time.
On the security side, we used IAM roles with least-privilege access, ensuring each Lambda only had permissions to the specific S3 buckets or services it needed.
For deployment, we used infrastructure as code (AWS CDK) with CI/CD pipelines for consistent releases. For monitoring, we relied on CloudWatch for logs, metrics, and alerts, and also used AWS X-Ray for distributed tracing to analyze latency and debug issues across services.
Additionally, in S3 we implemented lifecycle rules to optimize long-term storage costs, automatically transitioning objects to cheaper storage classes based on usage patterns.
This setup allowed us to scale efficiently while maintaining reliability, observability, and cost efficiency. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? ANGEL VILLAVICENCIO: Sure, in one project, we initially had multiple systems running under a monolithic architecture. They were stable and working well, but as the business grew, the setup became costly and harder to scale.
From a technical perspective, the ideal approach was to take time to analyze all the systems, define proper boundaries, and redesign the architecture into well-structured services. However, the business needed quick results and wasn’t willing to wait for a full redesign.
The conflict was between building a clean, long-term scalable architecture versus delivering immediate improvements.
We took an incremental approach. Instead of redesigning everything upfront, we identified the most critical systems and started decoupling them into independent services, keeping future scalability in mind. This allowed us to deliver value quickly while progressively improving the architecture.
The trade-off was not having the full picture from the start, which required adjustments later. However, it helped us gain stakeholder trust and evolve the system without disrupting operations.
We measured success through improved performance in key flows, reduced load on critical components, and faster feature delivery. - Fabián Andrés Bocanegra Castillo strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Fabián Andrés Bocanegra Castillo: I worked on a full-stack project using TypeScript, React, and Node.js, focused on building a clean task management application with a separated frontend and backend.
The frontend was built with React and TypeScript. I used typed components, hooks, and reusable UI structures. For state management, I intentionally keep it simple with React hooks instead of adding Redux or Zustand, because the state was not complex enough to justify that extra layer. My goal was to keep the proyect maintainable without overengineering it.
On the backend side, I used Node.js with TypeScript and structured the API around REST endpoints. In production environments, I usually prefer NestJS over plain Express when the project needs to scale, because NestJS provides a more options architecture: modules, controllers, services, dependency injection, DTOs, validation, and testing. Express is great for small services, but NestJS helps keep consistency as the codebase grows. One technical challenge was designing the backend in a way that business logic did not end up inside the routes. I separated responsibilities into controllers, services, DTOs, and infrastructure providers. That improved maintainability and made the project easier to test and extend.
Another challenge was deployment. Since the frontend and backend were deployed separately, I had to configure CORS, environment variables, and production API communication correctly. That made the project closer to a real production setup.
Overall, these decisions helped me build a more reliable and scalable application. TypeScript improved safety, React made the UI modular, and the backend architecture made the system easier to evolve Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Fabián Andrés Bocanegra Castillo: I haven’t used AWS directly in production, but I do have experience with GCP. I havve worked with cloud deployments and understand concepts like stateless services, scalability, and event-driven architectures. Services like AWS Lambda and S3 are conceptually similar to GCP Cloud Functions and Cloud Storage, which I’ve explored.
Given my backend experience, I’m confident I can quickly adapt to AWS. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Fabián Andrés Bocanegra Castillo: A good example was a project where users depends on CSV files delivered through an SFTP server.
The ideal technical solution would have been to replace that flow with an API-based integration, but the external system and the business process were already built around CSV files. The user pain point was not “we need a modern API”; else “we need this file-based process to be reliable and not require manual intervention.” So we build a Node.js backend process to read files from SFTP, validate the CSV structure, process records sure, handle malformed rows, avoid duplicated processing, and improve traceability through logs.
Success was measured by fewer manual interventions, fewer processing errors, better visibility in logs, and a more predictable workflow for userrs - Juan Eber Taype Escobar strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Juan Eber Taype Escobar: For a real-time dashboard project, I used Next.js (App Router), TypeScript, and NestJS.
The biggest challenge was data synchronization. We had a constant data stream via WebSockets, and if we didn’t handle it properly, the rendering would ruin the user experience and the backend would struggle under the load of connections.
I chose NestJS over Express because, for projects of this scale, Express quickly becomes chaotic. Nest provided me with a Dependency Injection structure and modules that made it much easier to scale the system and keep the types (DTOs) in sync with the frontend. It was key to ensuring the team didn’t break anything when making changes. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Juan Eber Taype Escobar: I’ve worked extensively with serverless architectures, primarily for data processing pipelines and automation. One specific example was a lead extraction engine that used S3 as a trigger to launch Lambda functions that processed large files and populated a database.
The challenge was that the volume of files was unpredictable; sometimes 5 would arrive, and other times 500 would come all at once. To handle scalability without hitting the account’s concurrent execution limit, I set up an SQS queue between the bucket and the Lambda. This allowed me to throttle the process and maintain a steady pace. For cold starts, since I was using Node.js, I optimized the package using esbuild to make the bundle lightweight (less than 5MB) and moved the database connection outside the handler to reuse it across executions.
I strictly follow the principle of Least Privilege. Instead of using generic roles, I created a specific IAM Role for the Lambda that only had s3:GetObject permissions on a specific prefix and sqs:ReceiveMessage. Additionally, I used VPC Endpoints so that traffic between the Lambda and S3 wouldn’t go out to the public internet.
I managed the deployment as Infrastructure as Code (IaC) using AWS CDK. I find this much cleaner than doing it manually because it allows for versioning of the infrastructure. For monitoring, I used CloudWatch Alarms to alert me if the error rate or latency increased, and I used X-Ray to see where time was being lost in the flow when there were bottlenecks. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Juan Eber Taype Escobar: For a report automation project, I initially designed an “ideal” architecture based on full SSR (Server-Side Rendering) so that users would always see up-to-date data when the page loaded. Technically, it was perfect because there was no data lag.
When the reports started to become very heavy, the Time to First Byte (TTFB) skyrocketed. Users complained that the screen remained blank for 8 to 10 seconds before anything appeared. To them, the app “didn’t work,” even though technically it was just processing.
My “ideal” solution was to maintain total consistency on the server side. But the “necessary” solution for the user was the perception of speed. I had to make a difficult architectural pivot: switching from SSR to a Shell + client-side fetching model with loading states (skeletons).
The decision: I sacrificed the elegance of server-side rendering for an asynchronous architecture. I implemented streaming with Suspense to send the web “shell” instantly so the user would feel like the app was already there, while the heavy data loaded in the background.
Not only did I see that the LCP (Largest Contentful Paint) dropped to under 2 seconds, but I also monitored the bounce rate on that specific page. By providing immediate visual feedback to the user, the bounce rate dropped by 40%. I realized that for the user, “fast” is better than “technically perfect but slow.” - Simon ESCOBAR medium fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Simon ESCOBAR: I choose NestJS because has a strong architecture and this is good for a long time development Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Simon ESCOBAR: I used lambdas for some special occasions, example return data from a S3 bucket like a PDF. I can see those logs of services through CloudWatch Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Simon ESCOBAR: I think that is necessary be aligned with business goals and understand your problems. If the current solution help to handle the code with very low friction, is a good indicator of good solution more than a good architecture - Ronaldo Sergio Jara Condori strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Ronaldo Sergio Jara Condori: One of my big tech challenge was creating an AI application called "Nawa method". I needed to choose all the tech stack and build all the architecture by myself, in this occasion I was evaluating NestJs and Express for backend , but comparing these alternatives I chose Nest over Express for two main reasons:
- First, it has its own structured architecture, its very easy to follow and you don't have to create and new special architecture. And also is easier to follow for new team members, and it is very helpful specially when you want to grow your team.
- Second, manage concurrency is easier than other frameworks, so on an application where you want to implement AI is very important to have a tool that helps with that.
To frontend, I choose React with React context, the challenge here was how to structure the global state because the application was planing to have a lot of interactivity and gamification so it was a real challenge but I try to divide responsibilities creating different stores managing just one thing instead of have a huge one and it helps a lot to the develoment. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Ronaldo Sergio Jara Condori: Honestly, I don't have hands-on experience with AWS Lambda or S3. Infrastructure and cloud services haven't been my main focus so far.
What I do have some experience with is monitoring and observability. I'll choose OpenTelemetry for monitoring and manage traces, logs and metrics. I think it's becoming the standard and it integrates well with most monitoring tools. For error tracking I've used Sentry, which I find very reliable for catching and diagnosing issues in production. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Ronaldo Sergio Jara Condori: Once I was building an MVP for a client that shifted mid-way from a CMS with AI to a completely different product — AI chatbots.
The ideal solution would've been to remove the old code entirely, but given the timeline I kept both systems coexisting in the same repo, heavily commented the old code and moved forward. It created technical debt, but it was the necessary call.
What saved me was having built a solid design system upfront — the UI stayed mostly intact, changes were mainly in routes and larger components. The client got their MVP on time, that was the measure that mattered. - Jean Carlos Vega Vidarte strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Jean Carlos Vega Vidarte: In a recent project, I contributed to a financial product affiliation platform using TypeScript, React with Next.js, and a Node.js backend. A key challenge was managing complex, interdependent state (coupons, campaigns, bank accounts), which I handled using Redux to ensure predictable updates and consistency across multi-step flows. On the backend, we adopted a microservices architecture with NestJS instead of Express due to its structured architecture, dependency injection, and TypeScript-first design, which improved maintainability, scalability, and team onboarding while enabling clear separation of domains like payments and user management. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Jean Carlos Vega Vidarte: I’ve implemented a serverless workflow using AWS Lambda and Amazon S3 to process PDF invoices that were scraped by another service. When a file was stored in S3, it triggered a Lambda function that handled parsing and processing. While the workload didn’t involve extreme scalability challenges, I still designed the flow to be event-driven and stateless, allowing it to scale automatically with incoming uploads. For security, I configured AWS Identity and Access Management roles with least-privilege access, ensuring the function could only read from the specific S3 bucket and write to required resources. For deployment, we used AWS CloudFormation to define and automate the provisioning of Lambdas, permissions, and triggers, which improved consistency across environments. Monitoring and logging were handled through CloudWatch, allowing us to track execution logs and debug issues when needed. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Jean Carlos Vega Vidarte: In a financial application, users reported they were unable to delete certain objects from the admin panel, which was blocking operational workflows. After investigating, I found the root cause in our multi-tenant architecture: we had foreign key relationships spanning different database schemas, and the ORM couldn’t reliably resolve those dependencies. The “ideal” solution would have been to fully normalize and strictly enforce cross-schema relationships, but that approach wasn’t practical given the ORM limitations and the immediate user impact. Instead, I made a pragmatic architectural pivot by constraining foreign keys to specific schemas and redesigning the deletion process—moving heavy dependency cleanup into an asynchronous workflow. This introduced some additional complexity in terms of eventual consistency, but it allowed deletions to complete reliably and without blocking the UI. We measured success by a drop in deletion-related errors, faster response times in the admin panel, and fewer support tickets from users experiencing this issue. - David Alberto Vique Almeida strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? David Alberto Vique Almeida: Thankiu, can you send me the link for upload the pre screening interview?? Sophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? David Alberto Vique Almeida: I will walk you through Commission Tracker, a production-grade app I built at Pinecrest Consulting to process and validate commissions for 50 plus companies using AI and OCR, with a frontend in Next.js React TypeScript and a backend in Node.js TypeScript running on AWS Lambda. The biggest challenge was managing state across a multi step asynchronous pipeline without blocking users, so I designed a database backed state machine plus queue based flows where each Lambda advances the file through well defined statuses and can safely retry without duplicating work. On the frontend I combined server side rendering for fast loading dashboards with client side data fetching and a React Query style cache for dynamic tables, keeping server state separate from UI state and using pagination and virtualization for performance. I chose a serverless Node TypeScript architecture instead of a monolithic Express or NestJS server because traffic is very spiky at month end, independent Lambdas scale automatically, deployments are granular, and strong typing across the stack keeps contracts stable as we add new companies and commission formats. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? David Alberto Vique Almeida: I have hands on experience building serverless workflows with AWS Lambda and S3 in production for AI driven apps like Commission Tracker, where users upload commission PDFs to S3 and a chain of Node TypeScript Lambdas handle OCR, LLM processing, and status updates for more than 50 companies. To handle scalability and cold starts I split the logic into small focused Lambdas with minimal dependencies and tuned memory and timeouts, following AWS guidance to keep packages lean and functions specialized. Each Lambda uses a least privilege IAM role with only the S3 and queue permissions it needs, S3 buckets are private, and we deploy through GitHub Actions pipelines that run tests and use an AWS Lambda deploy action, while CloudWatch logs and metrics provide monitoring and alerts on errors and latency. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? David Alberto Vique Almeida: In Commission Tracker, a production app for validating commissions for more than 50 companies, users were frustrated because a single generic prompt for all PDFs produced inconsistent extractions and too much manual correction. The technically ideal solution was that one unified prompt and a simple pipeline, but the necessary user solution was a multi prompt flow that first identifies the company and then selects a company specific prompt tailored to that format and business rules. This required adding a routing layer and storing prompt configs per company, making the architecture more complex, but success was clear: manual review time per batch and user reported issues dropped noticeably for high volume companies once the company first, then specific prompt flow was in place. - Rene Arias strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Rene Arias: I worked on a production-grade platform using TypeScript, Next.js, and Node.js/NestJS. We chose Next.js for SEO, SSR/ISR, and better initial performance. The main challenge was properly separating remote data from UI state, using tools like React Query for caching and invalidation Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Rene Arias: On the backend, we chose NestJS over Express because we needed modular architecture, dependency injection, validation, and testing. This helped us scale the project with less technical debt and better maintainability Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Rene Arias: I’ve implemented serverless workflows with AWS Lambda and S3, for example processing files when users uploaded them to a bucket. S3 triggered Lambda functions to validate, transform, and store the data. To handle scale, I made the functions idempotent and optimized the bundle to reduce cold starts; for critical paths, I would use provisioned concurrency. For security, I used least-privilege IAM roles per function. Deployment was managed with IaC like Serverless Framework/Terraform, and monitoring with CloudWatch logs, metrics, and alerts for errors, latency, and throttling - Carlos Hernández strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Carlos Hernández: In our digital signature application, we had a flow in which the user could scan a QR code through the cellphone to sign more easily
We had to take the decision to see how to notify the desktop app that the user had signed by the phone. We decided using websockets instead of using long-polling as it's a more performant solution
We used the socket-io library instead of a native WebSockets solutions as the rooms and namespaces management is easier that way.
With this decision, we gained more performance on both the frontend and the backend sides Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Carlos Hernández: I created an API for scraping real state pages using a stack of API Gateway + Lambda and S3 for saving the images of the properties
I created a Github Action workflow to handle the deployment of the Lambda funcion and improve the scability
Of course, I had to create IAM roles for the Lambda function to access the S3 bucket
For monitoring, I used CloudWatch logs and X-Ray logs Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Carlos Hernández: Sometimes deadlines are so short that doesn't give the team time to optimize solutions so it's always important to find spaces for fixing technical debt
Once the deployment of the feature was finished, we detected a bit of slowness in some of the services
We took ourselves some time to watch this, and we managed to reduce the response time and gained a lot of performance - Miguel Ramos strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Miguel Ramos: One production-grade project I worked on was a high-traffic booking and checkout platform built with TypeScript, Next.js14, and Node.js and Stripe.
The main challenge was checkout performance during peak traffic. We chose Next with SSR for dynamic booking pages and ISR for SEO-focused pages. On the frontend, we used React Query for caching and server-state management.
On the backend, we used Node.js services. I prefer NestJS for larger structured domains because of its modular architecture and scalability, while Express/Fastify works well for lightweight services.
We optimized queries, reduced unnecessary synchronous calls, and improved caching. As a result, checkout latency dropped by around 32%. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Miguel Ramos: I’ve used AWS Lambda and S3 in event-driven workflows for file processing, notifications, and backend APIs. One example was a document-processing flow where files uploaded to S3 triggered Lambdas to validate, transform, and store results in the database.
To handle scalability, Lambda auto-scaling helped during traffic spikes. For cold starts, we reduced package size, optimized dependencies, and used lightweight runtimes. For security, we applied least-privilege IAM roles so each function only accessed required S3 buckets and services.
For deployment, I used Serverless Framework / CI-CD pipelines. For monitoring, CloudWatch logs, metrics, and alerts to track errors, duration, and performance. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Miguel Ramos: On a booking platform, users were abandoning checkout because availability and pricing validations were too slow during peak traffic.
The ideal technical solution was a larger long-term refactor of multiple backend services. But the necessary user solution was to improve checkout speed quickly without disrupting production.
We prioritized targeted optimizations: caching frequent data, reducing synchronous calls, improving DB queries, and simplifying some validation flows.
We measured success through checkout latency, API response times, and conversion rates. The result was around 32% lower checkout latency and a smoother user experience with fewer drop-offs. - Angie Xiomara Pérez Muñoz strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Angie Xiomara Pérez Muñoz: ok, well… In a recent project, I worked on a web application to generate and send monthly reports to users. The stack was TypeScript with Next.js on the frontend and Node.js on the backend, using Supabase for database and automation.
One of the main challenges was state management, since the reports depended on multiple variables. I implemented React Query to handle async state and caching, focusing on defining when to cache and invalidate data. This significantly reduced unnecessary API calls and improved UI stability.
In Next.js, we used a combination of server-side rendering (SSR) and client-side rendering (CSR) depending on the use case. We relied on SSR for critical views like dashboards, and handled more dynamic interactions on the client. This helped us balance performance and user experience without overloading the backend.
On the backend, we used Express with a modular structure. I considered NestJS, but chose a lighter approach to move faster, while still keeping clear patterns that would allow the system to scale. We also used Prisma in some modules to ensure strong typing and consistency in database queries.
For automation, we implemented a cron job in Supabase to generate and send reports monthly. A key focus there was ensuring idempotency to avoid duplicate emails and guarantee reliability.
Overall, these decisions resulted in a fast, stable, and maintainable application, with a solid foundation to scale. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Angie Xiomara Pérez Muñoz: Following this same use case, once it was initially implemented with Supabase, and due to the growth of the application and the increase in user volume, it became necessary to migrate to a more robust architecture in AWS.
We redesigned the flow under a serverless approach using EventBridge, Lambda, S3, and Step Functions. We configured a rule in EventBridge to run the process monthly (for example, on the 3rd), which triggered a workflow orchestrated with Step Functions.
Within this flow, we defined two main Lambdas: one responsible for generating the report and storing it in S3, and another responsible for sending emails to users. Using Step Functions allowed us to have clearer control over the process, handle errors at each stage, and define retries without needing to reprocess the entire flow.
In terms of scalability, this architecture allowed us to handle multiple executions in parallel without relying on a centralized process, which was key as the number of users grew.
One of the challenges was handling cold starts, especially since the flow could also be triggered manually from the application. To mitigate this, in addition to keeping functions small and optimized, we defined a practical strategy: keeping the Lambdas “warm” during peak usage periods, specifically in the last and first days of each month, when both automatic sends and manual downloads were concentrated. This helped ensure more consistent response times during critical moments.
Regarding security, we configured IAM roles per Lambda, applying the principle of least privilege. Each function only had access to the resources it needed, such as specific S3 buckets or email services.
For deployment and monitoring, we used centralized logs and metrics to track each execution, along with alerts and controlled retries to ensure the reliability of the process.
This migration allowed us to have a more scalable, decoupled, and operationally visible flow, prepared to support the growth of the application. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Angie Xiomara Pérez Muñoz: In this same reporting project, we had to make an important architectural decision driven by a direct user need.
Initially, the system was designed to generate and send reports on a scheduled basis, which was efficient from a technical perspective. However, users started needing to generate and download reports in real time, with specific filters, without waiting for the monthly process.
That’s where the conflict appeared: the “ideal” solution was to keep controlled batch processes, but the “necessary” solution required supporting on demand executions, which introduced performance and consistency challenges.
We opted for a hybrid approach: we kept the automated monthly flow, but also enabled on demand report generation. This required adjusting the frontend to better handle states and user feedback, and adapting the backend to support faster, more efficient executions.
To avoid impacting the user experience, we didn’t block the user while the report was being generated. Instead, we handled intermediate states or deferred delivery when needed.
We measured success through increased feature adoption, reduced user friction, and acceptable response times. We also saw fewer issues related to outdated data, since users could access more up to date information when needed.
It was a good example of balancing a technically “ideal” solution with one that truly meets user needs. - Andres Felipe Diaz Gonzalez strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Andres Felipe Diaz Gonzalez: I'm ready Sophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Andres Felipe Diaz Gonzalez: Hi
I worked on a production platform using TypeScript, Next.js, and Node.js with NestJS, where I built an automation module end-to-end (frontend + backend), similar to GoHighLevel but using a tree-based workflow model instead of a free graph.
A key challenge was handling complex state and performance in a visual builder with drag-and-drop and nested conditional flows. I managed state using Zustand for local builder state and TanStack Query for server state, optimizing re-renders with selectors and memoization to avoid performance issues when editing multiple nodes.
On the backend, I designed a custom execution engine in NestJS that processes workflows sequentially using a FIFO queue, supports conditional branching, wait states (resumed via cron), and re-entry policies. Workflows were stored as structured types persisted in PostgreSQL JSONB, enabling versioning and flexibility.
I chose NestJS over Express for its modular architecture and dependency injection, which was critical for organizing a large system (~40 modules) and decoupling domains via an internal event bus.
Using TypeScript across the stack ensured type safety between frontend and backend, reducing runtime errors and improving maintainability. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Andres Felipe Diaz Gonzalez: I have experience working with AWS in backend deployments and integrations, including using S3 for file storage and cloud-based services, although my work has been more focused on containerized applications (Docker on EC2) rather than fully serverless architectures.
In one scenario, I used S3 for handling file storage and retrieval in a web application, ensuring proper access control using IAM policies and pre-signed URLs to securely upload and download files without exposing credentials. This helped maintain security while allowing controlled client-side interactions.
Regarding scalability, instead of Lambda-based workflows, I handled scaling at the application level using containerized services and backend optimizations. I’m familiar with the concepts of cold starts, stateless execution, and event-driven design in AWS Lambda, although I haven’t implemented a full production workflow using Lambda yet.
For deployment and monitoring, I have worked with AWS EC2, Docker, and basic logging/monitoring practices, ensuring services are stable in production and issues can be diagnosed effectively.
I’m currently interested in deepening my experience with serverless architectures (Lambda, event-driven workflows), as they align well with scalable system design. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Andres Felipe Diaz Gonzalez: In the automation module I built, a user reported that they couldn’t update existing workflows because the system was silently rejecting changes. From a technical standpoint, the “ideal” solution would have been to redesign the data model and validation layer to better support partial updates and nested entities.
However, the immediate need was to restore functionality quickly without introducing breaking changes. The issue was caused by strict backend validation (forbidNonWhitelisted) rejecting nested node IDs sent from the frontend.
Instead of a full refactor, I implemented a controlled preprocessing step on the client, removing non-required fields (like internal node IDs) before sending the request, while preserving them locally for editing purposes.
The success of the solution was measured by:
Users being able to save and update workflows without errors
No regression in existing automations
Reduced support issues related to workflow editing
This approach balanced technical correctness with product urgency, while leaving space for future architectural improvements. - Kevin Abel Brito Díaz strong fit
View conversationSophie: Walk me through a production-grade project where you used TypeScript, React/Next.js, and Node.js. Beyond the scope, focus on a complex technical challenge—such as state management, SSR/ISR optimization, or backend architecture. Why did you choose specific libraries (e.g., NestJS vs. Express), and how did those choices impact the final outcome? Kevin Abel Brito Díaz: One production-grade project that comes to mind was a large e-commerce initiative for Paris CL (Cencosud), where I worked as part of the engineering team delivering scalable customer-facing features and backend integrations.
The frontend stack was based on React, and the team selected this ecosystem because most developers already had strong experience with it, which accelerated delivery speed and reduced onboarding friction. We also benefited from the maturity of the ecosystem and strong community support.
On the backend, we chose NestJS over Express because the project required a more structured and scalable architecture. NestJS provided clear module separation, dependency injection, decorators, and better maintainability for a growing codebase with multiple contributors. This was especially valuable as the platform evolved and new services were added.
One of the main technical challenges was state consistency and integration between frontend flows and backend services, particularly in e-commerce processes where pricing, promotions, and inventory needed to stay synchronized. We addressed this by keeping frontend state predictable and centralizing business logic in backend services instead of duplicating rules on the client side.
From an engineering perspective, NestJS helped standardize patterns across the team, improve code organization, and simplify testing. The final outcome was faster collaboration, easier maintenance, and a platform architecture better prepared for future growth. Sophie: Describe your experience implementing serverless workflows using AWS Lambda and S3. Can you detail a specific instance where you had to handle scalability, cold starts, or security (IAM roles)? How did you manage deployment and monitoring for these services? Kevin Abel Brito Díaz: I’ve worked with AWS services in environments where serverless components were used to support integrations, file processing, and event-driven workflows.
A representative example involved handling file uploads and automated processing flows using Amazon S3 as the storage layer and Lambda functions to trigger validations and downstream processing after new files were uploaded.
One important challenge was scalability during peak usage periods, where multiple files could be uploaded simultaneously. The advantage of Lambda was the ability to scale automatically based on incoming events, which reduced the need to manage dedicated infrastructure.
Regarding cold starts, we minimized impact by keeping functions lightweight, reducing unnecessary dependencies, and designing logic to execute efficiently. For time-sensitive flows, we also paid attention to runtime selection and package size.
From a security standpoint, we followed least-privilege principles with IAM roles, ensuring each Lambda function only had access to the exact S3 buckets or AWS resources required.
For deployment, we used structured CI/CD workflows with version-controlled environments, which helped keep releases consistent and traceable.
For monitoring, we relied on centralized logs and execution metrics to track failures, duration, and retries, allowing quick troubleshooting and continuous optimization.
Overall, my focus in these architectures has always been reliability, maintainability, and operational efficiency. Sophie: Tell me about a time a specific user pain point dictated a difficult technical pivot or architectural decision. What was the conflict between the 'ideal' technical solution and the 'necessary' user solution? How did you measure the success of your fix? Kevin Abel Brito Díaz: One example that comes to mind was during an e-commerce project where users were experiencing friction during checkout because some product availability and promotional data were not updating fast enough in the purchase flow.
From a technical perspective, the “ideal” solution was to build a more complete real-time distributed architecture with multiple synchronized services and deeper event-driven communication. However, that approach required more implementation time and added unnecessary complexity for the immediate business need.
The necessary user-focused solution was to simplify the architecture and prioritize response speed and consistency in the checkout experience. We reworked critical API flows, optimized caching rules, and centralized some business validations server-side to reduce mismatches between frontend data and backend responses.
The result was a smoother checkout process, fewer cart abandonment issues related to pricing or stock inconsistencies, and faster page interactions during peak traffic periods.
We measured success through lower incident reports, improved response times, and better conversion behavior in the affected checkout steps.
That experience reinforced an important principle for me: elegant architecture matters, but solving the user’s pain point at the right time matters more.
| — | Apr 29, 13:22 | Interview completed |