Discuss the evolution from traditional Enterprise architectures to new architecture models like Apache NIFI

With the move to cloud, hybrid architectures and advances in technology the importance of Non-Functional Requirements (NFR) have never been more critical to Solution Design.

Non-functional Requirements define system attributes such as security, reliability, performance, maintainability, scalability, usability….the list goes on and on.

By defining the types of NFR’s to be considered and levels needed of the NFR’s during design phase (and throughout) will ultimately help define the solution expectations and boundaries. It will also help identify any risk areas.

I will introduce methodologies and collated ideas for quantifying NFRs that we have used in real large hybrid cross solution, multi cloud solution architectures.

Event-Driven Architecture became essential in modern applications built with microservices. It ensures that services are decoupled, allowing them to scale independently and moreover providing better resiliency. This talk will show why and how to build this kind of architecture on AWS, leveraging services like Amazon SNS, Amazon SQS or Amazon EventBridge.

Building an agile and reactive architecture is the holy grail for any Enterprise or Solution Architect.
Microservices, were introduced in 2014 by Martin Fowler as a subset of Service Oriented Architectures promising to deliver that.
Cloud Native and the perspective of infrastructure as a commodity is one key enabler to understand the advent of this architectural approach.
What can we learn from historical evolution of integrations problems, and how is Cloud Native impacting Solution Design inside organizations ?
In this session, besides getting the answers to these questions, we’ll explore the timeline of this evolution, and assess the real nature of these impacts with real examples, both on a Solution and Enterprise Architecture perspective.

This talk is about the distributed tracing platform that we have developed, how it is used, design, challenges and our future work.

Today programmers do not develop applications from scratch, but they spend their time fixing, extending, modifying and enhancing existing applications. The biggest problem in their daily work is that with time maintenance mutates from structured programming to defensive programming: The code becomes too complex to be maintained and accumulates technical debt. In this talk, you will see from various real-world examples how you can improve your architecture. You will understand how to prevent technical debt growing unrestricted and reduce maintenance costs for the future.

Serverless is eating the stack and developers are finding the way to build things quickly without worrying about capacity planning and other nuances. AWS Lambda is leading the pack but serverless does not necessarily restrict to just FaaS. Anything and everything where you don't manage the basic building blocks like compute, storage, memory and networking is serverless like AWS S3, GCP Big Query, DynamoDB etc..

In this talk, my focus would be to bring a solution using serverless stack from AWS to bring up a website with zero maintenance overhead of servers, near-zero cost and infinite scaling possibilities. It would be a very practical talk where the attendees would be able to absorb things quickly and the right pointers provided to do something on their own as well

Every startup needs to be able to scale while keeping the initial invest as low as possible. This is where cloud providers like AWS and Google Cloud come into play. They offer a very generous free tier and are able to support nearly infinite growth of you user base. But you have to plan your architecture correctly from the beginning, otherwise it can quickly become very expensive. This is the story of how we designed a highly available architecture for one of our clients, whose app scaled to millions of downloads and hundreds of thousands of MAOs while using the free tier as long as possible and keeping the maximum cost of the scaled application under 350$ per month.

GitHub is a free cloud platform for delivering well managed software projects from inception to delivery, but it can be used to deliver anything from documentation to infrastructure deployment. In this talk, Nick will show you how to use both an agile methodology, coupled with the amazing tools in github to deliver an end to end technology solution.
Attendees will learn and be shown how to deliver an entire project, including planning, documentation, software and release into production, all while using commercial grade free tools and to collaborate with a team of any size.
In this session, we create an application, all relevant documentation and plans and publish it to the world.

You will learn the relationship between business needs, lean computing and the 3 principles of DevOps.
The value of Infrastructure as Code and the pipeline automation to leverage it will be explained.
Most importantly, the Vision-Insight-Action framework to build a self-optimizing system will be demonstrated live and a solution based on AI to optimize performances, cost and compliance will be presented.

Empathy is a technical skill. Don’t worry. You read that correctly. While empathy is often cited as a critical “soft skill,” it doesn’t stop there. Empathy is also an incredibly technical topic that is more accessible to analytical engineers and more vital to building software than you might think. In this engaging keynote, Andrea Goulet, a noted expert on communication in the software industry, will debunk several myths around empathy. Empathy is a feeling? Nope? Technicians can’t access empathy? Nope. Empathy is just a high-level, touchy-feely fad? Nope. Andrea will demonstrate how empathy is a crucial skill for developing software and will focus on giving you practical and immediately actionable advice for making empathy a central focus of your daily development practice. You’ll walk away with a solid understanding of what empathy is, what it isn’t, how you can build your empathy skills, and a framework for using empathy while coding. If you’ve ever thought that you’re “good with machines” but have struggled to understand people, this is a talk you won’t want to miss.

The talk I would like to give is how a Developer can become an Architect. It is aimed at Developers who wish to transition into an Architecture role but need information on how an Architect performs their job. I have been an IBM Architect for over 12 years and mentor junior IBM employees in becoming Architects. My talk would cover topics such as the role of the Architect, developing the Architect mindset, the application of architectural thinking, technical leadership, managing technical risk, solution modelling, reference architectures, how to make the right Architecture Decisions for the solution.

The Solutions Architect position requires a really diverse set of skills and experiences. It is a much more generalist than specialist career which makes so difficult to track and hire great professionals for this role. To design your way to the Solutions Architect career is important to have development skills in order to understand the whole product lifecycle, and how to play with APIs and best advise the customer with integrations. It is also crucial to have infrastructure and architecture skills as you should be ready to advise the customers since the project planning, implementation, and expansion, regarding identity management, infrastructure architecture, integrations, automation and troubleshooting at complex environments. As if that were not enough, negotiation skills are crucial in order to handle customer, objections, frustrations and expectations. Lets wrap this up with empathy and a tech savvy profile and we have good reasons to believe we have a promising successful Solutions Architect ready to the best companies of the globe.

Offering a compelling experience to sports fan requires some out of the box thinking, along with some trial and error. See the architecture allowing us to serve live data to millions of concurrent users, during a sport event.

In this talk we will cover how to stream a live event everywhere using AWS Media Live and also adding a layer of interaction using AWS IVS (AWS Interactive Video Services)

I want to talk about .Net Clean Architecture Web API and Microservices.

First part of the speech , will be implementations and usage of the open source Clean.Architecture project
https://github.com/iayti/CleanArchitecture

In the second part of the speech, we can create an interactive part about Microservice architecture that listeners can participate in.

Why do we use microservice architecture?

Is it necessary to start with microservice architecture when starting our project?

When should we use microservice architecture?

What are the advantages and disadvantages of microservice architecture to us?

Serverless is the future for solving problems at scale. However, serverless can also include complicated setup to demonstrate the benefits for our customers. NextJS and an event emitting source let's us stand up complex examples quickly and efficiently that are ready to scale.

Many codebases contain code that is overly complicated, hard to understand and hence expensive to change and evolve. Prioritizing technical debt is a hard problem as modern systems might have millions of lines of code and multiple development teams — no one has a holistic overview. In addition, there's always a trade-off between improving existing code versus adding new features so we need to use our time wisely.

What if we could mine the collective intelligence of all contributing programmers and start making decisions based on information from how the organization actually works with the code?

In this presentation, you'll see how easily obtained version-control data lets you uncover the behavior and patterns of the development organization. This language-neutral approach lets you prioritize the parts of your system that benefit the most from improvements so that you can balance short- and long-term goals guided by data. The specific examples are from real-world codebases like Android, the Linux Kernel, .Net Core Runtime and more.

This new perspective on software development will change how you view code.

Most applications have a significant CreateReadUpdateDelete (CRUD) component. Most clients want agility and rapid adaptation. This talk addresses how we can effectively eliminate the CRUD component during development and provide runtime agility using live domain/application meta models with user interface and business logic patterns. Use of dynamic languages can enhance this further. The ideas will be demonstrated in a collaborative web modelling and knowledge management application.

In software development, we like to recognize good choices and identify them as patterns. This leads into implementing these patterns as best practices. But as we have good choices, we have bad choices as well. We identify them as antipatterns in order to avoid them in future projects. If you identify them in time, you can avoid them on your next project. Come and check what warning signs you need to look for!

Events are our industry’s near and dear. All technological conferences are full of talks on event sourcing, event driven architectures, or event driven integrations. So hey, why not make another one? …But a bit different: Let’s talk about the dark side of this pattern.

Events, as any tool, can be used productively or destructively. During the last 8 years, at Internovus, we found so many creative ways to do the latter:

* The different ways events can introduce coupling so strong, it will make the classic enterprise monolith envy
* Multiple ways of using events to introduce accidental complexity
* How to use events to turn a microservice into an architectural trojan horse; And
* Why some events, just like underwear, better be kept private

Those sights are not for the faint of heart, but fear not. You will get heuristics that will help you identify those situations, eliminate event-driven accidental complexities, and make event-driven architecture great again (MEGA™).

We all hear title “Software Architect”. It consistently makes the list of the most highly paid technical jobs. But what does it mean to be a software architect? What does a software architect do? And how do you become one? Perhaps someone gave you the title, but you are not sure what’s expected of you. Or perhaps you suspect you might already be doing a job of a software architect, but can’t quite pinpoint how you made the leap or explain it to others.

In this talk, I will define what a software architect does, and what skills you need to go from a senior developer to an architect.

When one’s app is challenged with poor performances, it’s easy to set up a cache in front of one’s SQL database. It doesn’t fix the root cause (e.g. bad schema design, bad SQL query, etc.) but it gets the job done. If the app is the only component that writes to the underlying database, it’s a no-brainer to update the cache accordingly, so the cache is always up-to-date with the data in the database.

Things start to go sour when the app is not the only component writing to the DB. Among other sources of writes, there are batches, other apps (shared databases exist unfortunately), etc. One might think about a couple of ways to keep data in sync i.e. polling the DB every now and then, DB triggers, etc. Unfortunately, they all have issues that make them unreliable and/or fragile.

You might have read about Change-Data-Capture before. It’s been described by Martin Kleppmann as turning the database inside out: it means the DB can send change events (SELECT, DELETE and UPDATE) that one can register to. Just opposite to Event Sourcing that aggregates events to produce state, CDC is about getting events out of states. Once CDC is implemented, one can subscribe to its events and update the cache accordingly. However, CDC is quite in its early stage, and implementations are quite specific.

In this talk, I’ll describe an easy-to-setup architecture that leverages CDC to have an evergreen cache.

Refactoring a monolith to serverless can be intimidating, but there are discrete steps that you can take to simplify the process. In this talk, AWS Serverless Hero Yan Cui outlines 8 steps to successfully refactor your monolith and highlight key decision points such as language and tooling choices.

Here's the challenge: we've got a Kafka topic, where services publish messages to be delivered to browser-based clients through web sockets.

Sounds simple? It might, but we're faced with an increasing number of messages, as well as a growing count of web socket clients. How do we scale our solution? As our system contains a larger number of servers, failures become more frequent. How to ensure fault tolerance?

The web socket connections from our users tend to disappear without warning, how to handle errors? Finally, what about message ordering and idempotence?

We'll discuss a couple of possible architectures, their strengths and weaknesses, as well as limitations created by the chosen technologies (Kafka and web sockets).

In a day and age when 4.4 billion dollars are lost annually worldwide due to poor web application performance, platform scalability is a clear direction for any existing and new systems on the market. However, due to high costs and too much time spent for writing and defining test cases, with current load testing solutions, organizations usually forget or choose to do these kind of tests only when it’s too
late or simply before big scheduled events such as Black Friday Sales.

Today, we’re going to take a look at a platform that is shifting this paradigm and is designed to be the first Performance Testing platform that can offer DDoS-level Application Performance Testing in just 3 minutes, while simulating workflows that emulate user experience.

Furthermore, we will be simulating a LIVE multi-distributed and coordinated Denial of Service attack through Internet of Things simulated devices to understand and better prepare our own applications for the worst.

Excited yet?

In this tech talk I would like to discuss tip and trick that we can use to scale our .net core web api application. We'll also look into different tools that can help us in analyzing our apis and figure out different bottle necks that effect the performance of the web api.

Cloud is inevitable. And secure. Are you ready to use it securely?

I will explain how IOT can help the manufacturing industry to act in a proactive and predictive way, building an architecture to receive the information from different sensors and send these information for a database in near real time, that others technologies can consume it to immediate actions.

Resilient architecture is crucial for all cloud implementations. In this talk, we explore different design patterns to make a distributed application more resilient.

As part of this journey, for any process, we need to ask what if something goes wrong? Then, plan a course of action to the process auto-heal without any human intervention and how to lower risks by performing canary deployments. Design starts with at first understanding of requirements and performing empathy map and value chain analysis.

Thinking application as stateless for all the API calls makes the system available most of the time requires creating a cache for common distributed data. Next, we examine how to deal with cascading failures, and timeouts scenarios. Applications, as part of auto-healing, need to Detect, Prevent, Recover, Mitigate, Complement so that the service is resilient.

Key takeaways for the audience are as follows:

Resiliency is essential for any feature in cloud
Understanding the value chain is critical to identify failure points
Challenges come in determining if there is a failure and design the system for auto healing
The focus should be first to prevent a failure to occur.
Identifying key challenges in your company and tools and techniques to auto-heal and provide a sustainable solution

Architect to architect discussion about the concepts behind data warehouse & big data architectures. Not specific to any vendor. Will introduce the main pieces of typical architecture and will review critically the cases against using just a typical architecture. This is an opinionated discussion that doesn’t have binary resolution but open minded thinking.

Our systems seldom fail all at once. Instead, an accumulation of failures adds up into a disaster, or a collection of latencies becomes an outage. What can we do to build systems that are more robust than our outage budgets? When do we need to decide to deliver less instead of nothing? And how can we possibly test our solutions under realistic conditions?

Perfectly optimized systems are extremely brittle -- we can see that now in a lot of our physical world. Systems operating near the limits of their capacity can be slow or intermittent. But systems with too much excess capacity are expensive. Finding the right balance of capacity needs and wiggle room means that organizations need to understand what they require and be able to change those requirements on the fly. How much and how fast can your system change to avoid breaking, or to take advantage of new opportunities?

Audiences will leave with new questions to ask about testing in production, automatic traffic management, application delivery, and modular designs.

Event Driven paradigm is one of the most popular micro services architecture. Many enterprises are levering this architecture in their digital journeys. With the promise to make enterprises more reactive to changing business needs. As part of this talk, I will talk about my experience of building enterprise event driven systems and at the same time elaborating the fallacies of building and adopting such systems.

One of the many benefits of building modern applications in the cloud is ability of building them in a such way, that would span across the globe. With the cloud you can design and build applications in multiple regions around the world with just a few clicks - this means you can provide lower latency and a better experience for your customers at minimal cost. In this presentation we will describe the rules and approaches of building systems which would span across multiple continents. We will describe the reasons of deploying systems across multiple data centers across the globe, approaches of reducing latency with content delivery network solutions and ways of defining global routing using DNS and other solutions.

At the beginning of this year we conducted an internal survey about our engineers’ skills development and career goals. One of its conclusions was that many would like to take more architect-type roles and focus on software design. This is how we came up with the Software Architecture Discussion Group. I’ll describe how we use Architectural Katas and Technology research meetings to create a platform where everyone can experiment. Especially architects!

How do we ensure the team starts creating the product with a shared understanding and an effective plan?, and how do we work out what should be in the MVP and start an agile project as quickly as possible?.
Lean Inception is the perfect methodology to start answering this questions.

My talk starts navigating practical examples (based on real projects), and presents three exercises to level up conversations between team members before building the product.

Most modern businesses depend on a portfolio of technology solutions to successfully operate every day. How do you know whether your team is following best practices or what the risks are in your architectures? In this session, we show how the AWS Well-Architected Framework provides prescriptive advice on best practices

Designing solutions can be as artistic as you want it to be, and sometimes one of the most important aspect of this process is determining when a piece fit or not. One of the most popular tendencies nowadays is using micro services, decoupling logic in multiple sections so you can manage the work in a more easy and clean way, however it can become messy when those said sections start to talk between them.
In this talk, I present a way to leverage the event-bus pattern for an ETL process (or more than one). Several times, I've faced a project where I need to pull information from different sources, and some linkage between them needs to be generated but coordinating all of that can be a major endeavor.

A walk-though of key constructs and architecture to be used when designing a resilient service in Azure both within a location and as a global solution.

When we hear event sourcing, it is usually around Kafka and containers.
While containers are great, serverless is even better!
But we can't ignore how big projects thrive with event sourcing...

Can we have the best of both worlds?

Join me on [date] where we will see how we can achieve a cheap, scalable and elastic serverless event sourcing architecture inside AWS!