These are the notes of the previous "How to Build a Portfolio That Reflects Your Real Skills" event:

Properties of an ideal portfolio repository:

• Built to prove employable skills and readiness for real work
• Fewer projects, carefully chosen to match job requirements
• Clean, readable, refactored code, and follows best practices
• Detailed READMEs (setup, features, tech stack, decisions, how to deploy, testing strategy, etc)
• Logical, meaningful commits that show development process <- you can follow the git history for important commits/features
• Clear architecture (layers, packages, separation of concerns) <- use best practices
• Unit and integration tests included and explained <-- also talk about them in the README
• Proper validation, exceptions, and edge case handling
• Polished, complete, production-like projects only
• “Can this person work on our codebase?” <-- reviewers will ask this
• Written for recruiters, hiring managers, and senior engineers
• Uses industry-relevant and job-listed technologies <- tech stak should match the CV
• Well-scoped, realistic features similar to real products
• Consistent style, structure, and conventions across projects
• Environment variables, clear setup steps, sample configs
• Minimal, justified dependencies with clear versioning
• Proper logging, and meaningful log messages
• No secrets committed, basic security best practices applied
• Shows awareness of scaling, performance, and future growth <- at least have a "possible improvements" section in the README
• a list of ADRs explains design choices and trade-offs <- should be a part of the documentation

📌 Backend & Frontend Portfolio Project Ideas

These projects are intentionally reusable across tech stacks. Following tutorials and reusing patterns is expected — what matters is:

• understanding the architecture
• explaining trade-offs
• documenting decisions clearly

☕ Junior Java Backend Developer (Spring Boot)

1. Shop Manager Application

A monolithic Spring Boot app designed with microservice-style boundaries. Features

• Secure user registration & login
• Role-based access control using JWT
• REST APIs for:
• Users
• Products
• Inventory
• Orders
• Automatic inventory updates when orders are placed
• CSV upload for bulk product & inventory import
• Clear service boundaries (UserService, OrderService, InventoryService, etc.)

Engineering Focus

• Clean architecture (controllers, services, repositories)
• Global exception handling
• Database migrations (Flyway/Liquibase)
• Unit & integration testing
• Clear README explaining architecture decisions

2. Parallel Data Processing Engine

Backend service for processing large datasets efficiently. Features

• Upload large CSV/log files
• Split data into chunks
• Process chunks in parallel using:
• ExecutorService
• CompletableFuture
• Aggregate and return results

Demonstrates

• Java concurrency
• Thread pools & async execution
• Performance optimization

3. Distributed Task Queue System

Simple async job processing system. Features

• One service submits tasks
• Another service processes them asynchronously
• Uses Kafka or RabbitMQ
• Tasks: report generation, data transformation

Demonstrates

• Message-driven architecture
• Async workflows
• Eventual consistency

4. Rate Limiting & Load Control Service

Standalone service that protects APIs from abuse. Features

• Token bucket or sliding window algorithms
• Redis-backed counters
• Per-user or per-IP limits

Demonstrates

• Algorithmic thinking
• Distributed state
• API protection patterns

5. Search & Indexing Backend

Document or record search service. Features

• In-memory inverted index
• Text search, filters, ranking
• Optional Elasticsearch integration

Demonstrates

• Data structures
• Read-optimized design
• Trade-offs between custom vs external tools

6. Distributed Configuration & Feature Flag Service

Centralized config service for other apps. Features

• Key-value configuration store
• Feature flags
• Caching & refresh mechanisms

Demonstrates

• Caching strategies
• Consistency vs availability trade-offs
• System design for shared services

🐹 Mid-Level Go Backend Developer (Non-Kubernetes)

1. High-Throughput Event Processing Pipeline

Multi-stage concurrent pipeline. Features

• HTTP/gRPC ingestion
• Validation & transformation stages
• Goroutines & channels
• Worker pools, batching, backpressure
• Graceful shutdown

2. Distributed Job Scheduler & Worker System

Async job execution platform. Features

• Job scheduling & delayed execution
• Retries & idempotency
• Job states (pending, running, failed, completed)
• Message queue or gRPC-based workers

3. In-Memory Caching Service

Redis-like cache written from scratch. Features

• TTL support
• Eviction strategies (LRU/LFU)
• Concurrent-safe access
• Optional disk persistence

4. Rate Limiting & Traffic Shaping Gateway

Reverse-proxy-style rate limiter. Features

• Token bucket / leaky bucket
• Circuit breakers
• Redis-backed distributed limits

5. Log Aggregation & Query Engine

Incrementally built system: Step-by-step

1. REST API + Postgres (store logs, query logs)
2. Optimize for massive concurrency
3. Replace DB with in-memory data structures
4. Add streaming endpoints using channels & batching

🐍 Mid-Level Python Backend Developer

1. Asynchronous Task Processing System

Async job execution platform. Features

• Async API submission
• Worker pool (asyncio or Celery-like)
• Retries & failure handling
• Job status tracking
• Idempotency

2. Event-Driven Data Pipeline

Streaming data processing service. Features

• Event ingestion
• Validation & transformation
• Batching & backpressure handling
• Output to storage or downstream services

3. Distributed Rate Limiting Service

API protection service. Steps

• Step 1: Use an existing rate-limiting library
• Step 2: Implement token bucket / sliding window yourself

4. Search & Indexing Backend

Search system for logs or documents. Features

• Custom indexing or Elasticsearch
• Filtering & time-based queries
• Read-heavy optimization

5. Configuration & Feature Flag Service

Shared configuration backend. Steps

• Step 1: Use a caching library
• Step 2: Implement your own cache (explain in README)

🟦 Mid-Level TypeScript Backend Developer

1. Asynchronous Job Processing System

Queue-based task execution. Features

• BullMQ / RabbitMQ / Redis
• Retries & scheduling
• Status tracking

2. Real-Time Chat / Notification Service

WebSocket-based system. Features

• Presence tracking
• Message persistence
• Real-time updates

3. Rate Limiting & API Gateway

API gateway with protections. Features

• Token bucket / sliding window
• Response caching
• Request logging

4. Search & Filtering Engine

Search backend for products, logs, or articles. Features

• In-memory index or Elasticsearch
• Pagination & sorting

5. Feature Flag & Configuration Service

Centralized config management. Features

• Versioning
• Rollout strategies
• Caching

🟨 Mid-Level Node.js Backend Developer

1. Async Task Queue System

Background job processor. Features

• Bull / Redis / RabbitMQ
• Retries & scheduling
• Status APIs

2. Real-Time Chat / Notification Service

Socket-based system. Features

• Rooms
• Presence tracking
• Message persistence

3. Rate Limiting & API Gateway

Traffic control service. Features

• Per-user/API-key limits
• Logging
• Optional caching

4. Search & Indexing Backend

Indexing & querying service.

5. Feature Flag / Configuration Service

Shared backend for app configs.

⚛️ Mid-Level Frontend Developer (React / Next.js)

1. Dynamic Analytics Dashboard

Interactive data visualization app. Features

• Charts & tables
• Filters & live updates
• React Query / Redux / Zustand
• Responsive layouts

2. E-Commerce Store

Full shopping experience. Features

• Product listings
• Search, filters, sorting
• Cart & checkout
• SSR/SSG with Next.js

3. Real-Time Chat / Collaboration App

Live multi-user UI. Features

• WebSockets or Firebase
• Presence indicators
• Real-time updates

4. CMS / Blogging Platform

SEO-focused content app. Features

• SSR for SEO
• Markdown or API-based content
• Admin editing interface

5. Personalized Analytics / Recommendation UI

Data-heavy frontend. Features

• Filtering & lazy loading
• Large dataset handling
• User-specific insights

6. AI Chatbot App — “My House Plant Advisor”

LLM-powered assistant with production-quality UX. Core Features

• Chat interface with real-time updates
• Input normalization & validation
• Offensive content filtering
• Unsupported query detection
• Rate limiting (per user)
• Caching recent queries
• Conversation history per session
• Graceful fallbacks & error handling

Advanced Features

• Prompt tuning (beginner vs expert users)
• Structured advice formatting (cards, bullets)
• Local LLM support
• Analytics dashboard (popular questions)
• Voice input/output (speech-to-text, TTS)

✅ Final Advice

You do NOT need to build everything. Instead, pick 1–2 strong projects per role and focus on depth:

• Explain the architecture clearly
• Document trade-offs (why you chose X over Y)
• Show incremental improvements
• Prove you understand why, not just how

📌 Portfolio Quality Signals (Very Important)

• Have a large, organic commit history → A single or very few commits is a strong indicator of copy-paste work.
• Prefer 3–5 complex projects over 20 simple ones → Many tiny projects often signal shallow understanding.

🎯 Why This Helps in Interviews

Working on serious projects gives you:

• Real hands-on practice
• Concrete anecdotes (stories you can tell in interviews)
• A safe way to learn technologies you don’t fully know yet
• Better focus and long-term learning discipline
• A portfolio that can be ported to another tech stack later (Java → Go, Node → Python, etc.)

🎥 Demo & Documentation Best Practices

• Create a 2–3 minute demo / walkthrough video
• Show the app running
• Explain what problem it solves
• Highlight one or two technical decisions
• At the top of every README:
• Add a plain-English paragraph explaining what the project does
• Assume the reader is a complete beginner

🤝 Open Source & Personal Projects (Interview Signal)

Always mention that you have contributed to Open Source or built personal projects.

• Shows team spirit
• Shows you can read, understand, and navigate an existing codebase
• Signals that you can onboard into a real-world repository
• Makes you sound like an engineer, not just a tutorial follower

Apply cutting-edge machine learning techniques—from crowdsourced relevance and knowledge graph learning, to Large Language Models (LLMs)—to enhance the accuracy and relevance of your search results. Delivering effective search is one of the biggest challenges you can face as an engineer. AI-Powered Search is an in-depth guide to building intelligent search systems you can be proud of. It covers the critical tools you need to automate ongoing relevance improvements within your search applications. Inside you’ll learn modern, data-science-driven search techniques like: Semantic search using dense vector embeddings from foundation models Retrieval augmented generation (RAG) Question answering and summarization combining search and LLMs Fine-tuning transformer-based LLMs Personalized search based on user signals and vector embeddings Collecting user behavioral signals and building signals boosting models Semantic knowledge graphs for domain-specific learning Semantic query parsing, query-sense disambiguation, and query intent classification Implementing machine-learned ranking models (Learning to Rank) Building click models to automate machine-learned ranking Generative search, hybrid search, multimodal search, and the search frontier AI-Powered Search will help you build the kind of highly intelligent search applications demanded by modern users. Whether you’re enhancing your existing search engine or building from scratch, you’ll learn how to deliver an AI-powered service that can continuously learn from every content update, user interaction, and the hidden semantic relationships in your content. You’ll learn both how to enhance your AI systems with search and how to integrate large language models (LLMs) and other foundation models to massively accelerate the capabilities of your search technology. About the Technology Modern search is more than keyword matching. Much, much more. Search that learns from user interactions, interprets intent, and takes advantage of AI tools like large language models (LLMs) can deliver highly targeted and relevant results. This book shows you how to up your search game using state-of-the-art AI algorithms, techniques, and tools. About the Book AI-Powered Search teaches you to create a search that understands natural language and improves automatically the more it is used. As you work through dozens of interesting and relevant examples, you’ll learn powerful AI-based techniques like semantic search on embeddings, question answering powered by LLMs, real-time personalization, and Retrieval Augmented Generation (RAG). What's Inside Sparse lexical and embedding-based semantic search Question answering, RAG, and summarization using LLMs Personalized search and signals boosting models Learning to Rank, multimodal, and hybrid search About the Reader For software developers and data scientists familiar with the basics of search engine technology. About the Author Trey Grainger is the Founder of Searchkernel and former Chief Algorithms Officer and SVP of Engineering at Lucidworks. Doug Turnbull is a Principal Engineer at Reddit and former Staff Relevance Engineer at Spotify. Max Irwin is the Founder of Max.io and former Managing Consultant at OpenSource Connections. Quotes Belongs on the shelf of every search practitioner! - Khalifeh AlJadda, Google A treasure map! Now you have decades of semantic search knowledge at your fingertips. - Mark Moyou, NVIDIA Modern and comprehensive! Everything you need to build world-class search experiences. - Kelvin Tan, SearchStax Kick starts your ability to implement AI search with easy to understand examples. - David Meza, NASA

Hands-on workshop on building a search engine from scratch, focusing on text search and vector search. Topics include in-memory text search, tokenization and preprocessing, inverted index construction, embeddings, converting text to vectors, cosine similarity, and strategies to combine text and vector search. The session includes practical coding in a Jupyter Notebook using Python to implement both text and vector search approaches.

Join us for a meetup on September 14th at 18.30 at Zalando, Berlin!

18:30: Join us for a drink

Please have your full and real name in your profile description because the security team will check if you're registered when you arrive.

18:45: Rankquest: Benchmarking Search API Ranking with Elasticsearch (Jilles van Gurp)

Search Ranking is something that many companies that use Elasticsearch struggle with.

Something we noticed while helping various clients is that many companies never evolve to having a systematic approach for testing their search ranking quality. It's too abstract for them; they don't know where to start with this, and they don't really get how this should be done or even why this is important.

In this presentation we present and unveil our new ranking tool, Rankquest Studio, which aims to address some of these issues. Rankquest emerged out of our frustration with existing tools and approaches in this space and we'll reflect a bit on the requirements we have for this before diving into a demo. Rankquest Studio, is open source, web-based, easy to use, and it can be used to to build out test benchmarks for evaulating your search solutions.

19:15: Generative Black-Box Testing for Evaluating Search Quality (Oliver Trosien @ Zalando)

We present a novel generative Black-Box Testing approach that uses semantically equivalent queries (e.g. “rote Kleider”, “Kleid rot”) for introspecting the quality of a search engine. At Zalando, we developed a tool for finding search quality problems at scale with the help of mass-generating semantically equivalent query variants. This is a novel way to find relevance problems that complements other approaches that use customer metrics or ground truth data. The tool allows easy extension with new test scenarios and languages by non-technical native language speakers. We will show how it was used to continuously monitor search relevance, to find regressions, and how you can implement such a tool yourself. Here are some questions that we’ll discuss in the session:

• How can you track search quality at scale?
• What kind of quality issues does generative black-box testing (not) uncover?
• Can it be used to test semantic or vector search quality?

20.00: Pizza

Special thanks to our hosts, Zalando!

Traditional cybersecurity Security Information and Event Management (SIEM) ways do not scale well for data sources with 30TiB per day, leading HSBC to create a Cybersecurity Lakehouse with Delta and Spark. Creating a platform to overcome several conventional technical constraints, the limitation in the amount of data for long-term analytics available in traditional platforms and query languages is difficult to scale and time-consuming to run. In this talk, we’ll learn how to implement (or actually reverse-engineer) a language with Scala and translate it into what Apache Spark understands, the Catalyst engine. We’ll guide you through the technical journey of building equivalents of a query language into Spark. We’ll learn how HSBC business benefited from this cutting-edge innovation, like decreasing time and resources for Cyber data processing migration, improving Cyber threat Incident Response, and fast onboarding of HSBC Cyber Analysts on Spark with Cybersecurity Lakehouse platform.

Connect with us: Website: https://databricks.com Facebook: https://www.facebook.com/databricksinc Twitter: https://twitter.com/databricks LinkedIn: https://www.linkedin.com/company/data... Instagram: https://www.instagram.com/databricksinc/