Otavio Santana’s Post

MongoDB Atlas offers a powerful document model, enabling you to store data as JSON-like objects that closely resemble your application code. Read more 👉 https://lttr.ai/Ap3jo #Java #NoSQL #MongoDB

Requirement: FIAS Data Sync Middleware Apply for this new project https://lnkd.in/dxYbZEpZ I need a compact middleware script—your choice of Python or Node.js—that pulls JSON payloads from a REST endpoint hosted on AWS and forwards them, in near real-time, to a local device that only understands the FIAS protocol over raw TCP/IP sockets. The flow is straightforward: authenticate to the AWS API, poll or subscribe for new records, validate and, when necessary, transform the JSON, store or stage it in the local PostgreSQL instance, then push each record down the wire using FIAS commands so the on-prem device stays perfectly in sync with the cloud source. Robust logging, reconnection logic, and graceful error handling are essential because the local connection can be unreliable. Configuration items such as AWS credentials, polling interval, socket host/port, and retry limits should live in a separate file or environment variables for quick tweaking without code edits. Deliverables • Clean, well-commented source code (Python or Node.js) • Sample config file with placeholders for secrets • Setup instructions and one-command launch script (systemd service file is a plus) • Short README that documents the data flow, FIAS message structure you implemented, and how to extend the field mapping • Proof-of-concept run that shows data fetched from AWS, written into PostgreSQL, and echoed by the local device via FIAS If you have prior experience with socket programming, FIAS, or AWS SDKs, let me know—otherwise I’m happy to share sample payloads and the device’s FIAS spec so you can start right away. right away. Skills Required Python NoSQL Couch & Mongo Amazon Web Services Node.js PostgreSQL JSON API Development REST API Mobisium → mkt@mobisium.com pratham.parab@mobisium.com Let’s build something impactful together at MOBISIUM #Hiring #BackendDevelopment #AWS #APIDevelopment #Python #NodeJS #PostgreSQL #SocketProgramming #SystemIntegration #Mobisium

🚀 Backend Learning | Caching Patterns for High-Performance Systems While working on backend systems, I recently explored different caching strategies used to improve performance and scalability. 🔹 The Problem: • Frequent database hits increasing latency • High load under traffic • Need for faster response times 🔹 What I Learned: • Cache Aside (Lazy Loading): Load data into cache on demand • Write Through: Write to cache and DB simultaneously • Write Back (Write Behind): Write to cache first, DB updated later 🔹 Key Insights: • Cache Aside → Simple & widely used • Write Through → Strong consistency • Write Back → High performance but complex 🔹 Outcome: • Reduced database load • Faster API responses • Better system performance Caching is not just about storing data — it’s about choosing the right strategy. 🚀 #Java #SpringBoot #Redis #SystemDesign #BackendDevelopment #Caching #LearningInPublic

🚀 Backend Learning | Caching vs Database — When to Use What? While working on backend systems, I recently explored an important decision — when to use cache and when to rely on the database. 🔹 The Problem: • Frequent DB calls increasing latency • Need for faster responses under heavy traffic • Balancing performance with data consistency 🔹 What I Learned: • Cache (Redis): Best for frequently accessed, read-heavy data • Database: Best for reliable, consistent data storage • Cache improves speed, DB ensures correctness 🔹 Key Trade-offs: • Cache → Fast but may serve stale data • DB → Accurate but slower under load • Choosing depends on use-case and consistency requirements 🔹 Outcome: • Better performance optimization decisions • Improved system design thinking • Balanced speed vs consistency Good backend design is not about choosing one — it’s about choosing the right tool at the right time. 🚀 #Java #SpringBoot #Redis #Database #SystemDesign #BackendDevelopment #LearningInPublic

Hi. My work is primarily around big data processing using spark and the azure ecosystem. I recently got interested in API design and high scale systems that cater to multiple users at once. In order to understand the space better I designed and implemented a high concurrency ticket booking system. The backend relies on python, FastAPI and PostgreSQL. A redis cache is implemented to offload the ticket booking system from the database. Redis being single threaded and in-memory ensures no double booking happens for the same event and handles race conditions gracefully while delivering sub 15ms response times. The user doesn't overload the database as all the requests first hit the redis cache. The ticket counts for the events are periodically reconciled between the cache and the persistent database. The system was load tested using the locust framework. It handles 500 requests per second. This was my first time working on an API development. It was really fun seeing it work. Feel free to have a look at the repo - https://lnkd.in/g_77-hQf

💻 Turning ideas into scalable backend systems… one API at a time 🚀 Over the past 2.5+ years, I’ve been building robust backend solutions using Python & Django — focusing on performance, security, and real-world impact. ✨ What I’ve been working on: 🔐 Secure authentication systems (JWT & RBAC) ⚡ High-performance REST APIs & PostgreSQL optimization 🧩 Scalable microservices architecture 🚀 Caching & performance tuning (Redis / Memcached) 🔗 Third-party API integrations 📈 Currently leveling up with CI/CD, system design, and deployment workflows to build more efficient and scalable systems. I enjoy solving challenging problems and collaborating with teams that build meaningful products. 🔥 Accepting new challenges and leveling up my skills in the backend/Python ecosystem. If you’re building something exciting — let’s connect 🤝 #PythonDeveloper #Django #BackendDevelopment #APIs #PostgreSQL #Microservices #TechCareers

🍃 MongoDB Notes Every Developer Should Know 🚀 💡 MongoDB isn’t just about storing data — it’s about designing scalable databases. If you're learning backend or MERN, mastering MongoDB is a must. 🔥 Which MongoDB topic took you the longest to understand? 👇 #MongoDB #Database #BackendDevelopment #MERNStack #MEANStack #FullStack #NodeJS #WebDevelopment #Programming #Developer #Coding #SoftwareDevelopment #NoSQL #LearnToCode #Developers #Tech #DatabaseDesign

I tried to fork Redis and embed ONNX Runtime in C. After a week of segfaults, I asked myself: why am I torturing myself with C when I've been writing Java for 12+ years? So I built my own Redis from scratch. Here's the backstory: We were building a multi-agent system for production incident investigation. 6 AI agents running in parallel — logs, metrics, PagerDuty, Confluence, Slack, history — each digging through its own data source. The problem? They had no shared memory. LogsInvestigator found OOMKilled — that's the root cause. But MetricsInvestigator didn't know. It was building its own theory about CPU spikes. The Synthesizer got 3 competing hypotheses, 2 of which were garbage. I looked at what's available: → Mem0: REST API + external embeddings + Docker + custom SDK → Zep: REST API + Postgres + external embeddings + custom SDK → Redis Stack: RESP protocol, but embeddings still external Every solution required network calls for embeddings. Three hops to save one fact. For working memory — that's unacceptable. So I built Agentis Memory: ✦ Speaks Redis protocol (RESP) — any Redis client works out of the box ✦ Embeddings computed locally via ONNX Runtime (all-MiniLM-L6-v2) ✦ Single binary ~150MB, zero dependencies ✦ No API keys, no REST, no custom SDKs Two commands that change everything: • MEMSAVE key "text" → chunks, embeds, indexes automatically • MEMQUERY namespace "query" 5 → semantic search in milliseconds The fun part about performance: First version on plain JVM → 2x slower than Redis 😅 After GraalVM native-image + SIMD via Java Vector API → 1.36x FASTER than Redis 168K ops/sec vs Redis's 123K. At pipeline depth 100 → 3.19M ops/sec. And yes — I benchmarked it against Redis 7.4, Dragonfly, and Lux. Honest numbers, no cherry-picking. Now Claude Desktop, Claude Code, Codex, and Junie all share memory through Agentis Memory. Agents understand context faster, make fewer mistakes, don't duplicate work. The project is open source (Apache-2.0). Detailed write-up with benchmarks and architecture: https://lnkd.in/diREt3cs GitHub: https://lnkd.in/dAEgsuJn

Tried building something I usually only read about in system design interviews… 👉 How do systems handle millions (or even billions) of existence checks without killing the database? So I built a distributed Bloom Filter system using Spring Boot. 💡 The problem: If every request (like username/email check) hits the database → it doesn’t scale. Even caching isn’t enough when traffic gets really high. ⚙️ What I built: A production-style Bloom Filter system with: Spring Boot Redis + RedisBloom Lettuce MurmurHash3-based sharding Batch operations (BF.MADD, BF.MEXISTS) 🧠 The interesting part (what I learned): Instead of using a single Bloom filter, I split it into multiple shards like: bf:users:shard:0 bf:users:shard:1 ... Then: Each item is routed using MurmurHash3 Batch requests are grouped per shard Executed in parallel using Redis This avoids hot keys and scales horizontally. ⚡ Performance improvements: Sub-millisecond checks (in-memory Redis) Huge reduction in DB calls Handles large batch inputs efficiently 📊 I also added: Metrics (latency, batch size, hit/miss rates) Health checks for RedisBloom + shard integrity Auto-configuration of filters on startup 📦 Built with scale in mind: Supports billions of items Configurable error rates (false positives) Shard-based distribution I’ve shared the full implementation here 👇 🔗 https://lnkd.in/dyWp8xSn Honestly, implementing this gave me a much clearer understanding of: cache penetration problems probabilistic data structures how real systems avoid bottlenecks Still exploring improvements like dynamic shard scaling and better tuning. Would love feedback or suggestions 🙌 #systemdesign #backend #springboot #redis #java #scalability #distributed #engineering

Completed Episode 13 "Creating a database & mongodb " of Namaste Node.js season -1 #NamasteNodejs by Akshay Saini 🚀 Diving into the world of NoSQL databases with MongoDB! • Learned how to install and set up MongoDB locally 🛠️ • Explored MongoDB Atlas for cloud database management ☁️ • Used MongoDB Compass for visual database interaction 🔍 • Created and managed projects & clusters in Atlas 🧩 • Connected applications to MongoDB databases seamlessly 🔗 • Learned how to create and manage databases efficiently 💾 • Understood core CRUD operations (Create, Read, Update, Delete) 🔄 • Covered best practices for scalable and clean database design 🧠 • Built a strong foundation in NoSQL concepts 🔥 #MongoDB #NoSQL #BackendDevelopment #WebDevelopment #FullStackDeveloper #JavaScript #NodeJS #Database #DatabaseDesign #CRUD #SoftwareEngineering #Programming #Coding #Developers #DeveloperLife #CodingJourney #LearnToCode #CodeNewbie #TechContent #BuildInPublic #100DaysOfCode #DevCommunity #TechSkills #CareerGrowth #OpenToWork #CodingTips #ProgrammingLife #WebDev #Backend #APIDevelopment #TechEducation