70-487 Exam Guide: Historical Scope, Skills, and a Practical Study Plan
Exam 70-487, Developing Microsoft Azure and Web Services, was designed to validate professional development skills for building web solutions and services with Visual Studio, the Microsoft .NET Framework, and Azure-related technologies. It served developers working with ASP.NET MVC applications, data access, and service integration. The most important decision today is whether you need the retired exam as historical evidence or should pursue a current role-based credential instead; this guide helps you make that choice and use the old blueprint productively.
What 70-487 was intended to validate
70-487 assessed the ability to design and develop web applications that work with local and remote data and services, including Windows Azure. Its scope was broader than a single framework feature: the objective domain covered data access, Entity Framework, services, storage, caching, transactions, XML, and the software development life cycle for data and service solutions.
Microsoft identified the exam as “Developing Microsoft Azure and Web Services.” The official objective-domain document describes candidates as professional developers who use Visual Studio and the Microsoft .NET Framework to design and develop web solutions. This makes the exam a historical measure of implementation judgment across an application stack, not merely a vocabulary test.
A candidate studying the objectives should therefore ask practical engineering questions: How should an application retrieve and update data? Which service boundary fits the requirement? How should transactions and caching be handled? How can a solution work with remote services and Azure storage? Those questions better reflect the blueprint than memorizing isolated API names.
The intended candidate profile
The objective-domain document presents a relatively experienced audience. It says candidates should have three to five years of experience developing ASP.NET MVC-based solutions and experience designing and developing web applications that access local and remote data and services, including Windows Azure.
That expectation matters when planning preparation. A developer who has built applications can use the blueprint to identify gaps in a familiar workflow. A learner with only classroom exposure may need to build small working solutions before attempting detailed objective review. In either case, the document describes an expected background rather than a guarantee of a particular question format or pass outcome.
Is 70-487 still available to schedule?
No current scheduling or delivery details should be assumed for 70-487. Microsoft’s retirement policy states that once an exam is retired, candidates cannot take it or earn the associated certification or credential after the retirement date. The supplied Microsoft retirement material identifies 70-487 among the exams associated with the retiring MCSA, MCSD, and MCSE program.
The supplied Microsoft communications contain different retirement references: one update states that remaining MCSA, MCSD, and MCSE exams, including 70-487, would retire on January 31, 2021, while another retirement announcement lists the program exams as retiring on June 30, 2020. Regardless of which historical announcement a reader encounters, both dates are in the past. The current decision is not how to book 70-487, but whether its objectives are useful for legacy study or skills transfer.
Microsoft also states that training content for retired exam areas may remain available after retirement. That does not make the exam active. Treat old exam pages, third-party listings, and archived practice material as historical references unless the official Microsoft certification system confirms a current offering.
What retirement means for older certification records
Microsoft’s current retirement policy says an already-earned certification remains on a candidate’s Microsoft Learn transcript after the associated exam retires. A certification earned or renewed before retirement stays in the Active Certifications section until it expires; after expiration, it moves to the Historical Certifications section.
This distinction is useful for employers and candidates reviewing older records. Retirement does not erase a credential that was legitimately earned. It does mean that a new candidate cannot use 70-487 today to earn the retired exam or rely on it as a current scheduling option.
Do not infer a current replacement from the old title
Microsoft published a mapping article for selected 70-xxx exams and newer role-based certifications, but the supplied mapping facts do not establish a direct replacement for 70-487. The old Azure and web-services focus should not be treated as proof that a particular current Azure developer exam has identical objectives.
If your goal is a current credential, start with the job role you want to demonstrate and compare the active Microsoft certification page with your experience. Use the 70-487 blueprint as background for data and service concepts, not as evidence that an old exam maps one-for-one to a current exam.
Which domains deserve the most study time?
The two explicitly weighted domains in the supplied objective-domain evidence are both substantial: “Accessing Data” represents 20–25% of the exam, and “Querying and Manipulating Data by Using the Entity Framework” also represents 20–25% of the exam. Plan around those named domains rather than treating every topic as equally important.
The percentages describe the published exam domain weights, not a guaranteed count of questions or a prediction of a particular test form. Microsoft can revise objectives and exam structures, and this exam is retired. For historical preparation, the weights are still useful for prioritizing hands-on practice.
Accessing Data: build the complete path
The “Accessing Data” domain represents 20–25% of the exam. The objective-domain material connects this area with data-access technologies such as ADO.NET, WCF Data Services, and Azure DocumentDB/Cosmos DB, as well as application access to local and remote data.
Study this domain as an end-to-end path: define the data source, establish the access mechanism, retrieve or update data, handle errors, manage resource lifetime, and expose the result to the application. Compare approaches instead of learning them as unrelated products. For example, identify what changes when a solution moves from a local relational data source to a remote service or document-oriented store.
A useful lab is a small web application with separate data-access code and a service boundary. Add validation, failure handling, and logging. Then change one assumption at a time, such as the data source or service location. The purpose is to understand the design consequences, not to reproduce a memorized code listing.
Entity Framework: reason about queries and changes
The “Querying and Manipulating Data by Using the Entity Framework” domain represents 20–25% of the exam. Its emphasis is operational: querying data, shaping results, tracking or applying changes, and selecting suitable Entity Framework behavior for an application’s needs.
Begin with a model and a small set of related entities. Practice filtering, projection, ordering, grouping, relationship loading, inserts, updates, deletes, and concurrency or transaction considerations where relevant to the application. For each operation, inspect what data is requested and when work occurs. This habit helps distinguish an efficient query from code that retrieves too much data and filters it later.
Do not make a flashcard list of method names your main strategy. Write a requirement in plain language, implement it, inspect the result, and explain why the query belongs in the data layer. Repeat the exercise with related entities and a change operation so that querying and manipulation become connected decisions.
Supporting implementation topics
The objective-domain evidence also includes implementing caching, transactions, Azure data storage, WCF Data Services, XML manipulation, and Entity Framework data operations. These topics are best studied through failure and performance scenarios because their value depends on when and why they are used.
For caching, define what can be reused, how stale data is handled, and what event should invalidate it. For transactions, identify the unit of work and the consequences of a partial failure. For XML, practice reading, transforming, validating, and safely handling malformed input. For Azure data storage, connect the storage choice to the data shape, access pattern, and service boundary.
Keep a decision record for each lab. Write the requirement, selected technology, rejected alternative, failure case, and test that demonstrates the behavior. This creates reusable engineering reasoning and exposes gaps more effectively than rereading a product summary.
How should you prepare when the exam is retired?
Use a two-stage plan: first verify that you are studying for the right credential, then use the 70-487 objectives as a skills checklist. Do not spend money or schedule time based on a third-party claim that the exam is active. If you need a current certification, move to an active role-based path; if you need legacy knowledge, build and test the underlying web, data, and service skills.
A retired blueprint can still support professional development, migration work, maintenance of older applications, or preparation for interviews involving the technologies it covered. It cannot by itself establish current Azure competence. Keep those two purposes separate in your study plan and on your résumé.
Step 1: decide your outcome before opening study material
Write one target: preserve historical knowledge, prepare for work on a legacy .NET solution, or earn a current Microsoft credential. The target determines whether 70-487 is a useful study outline or a poor destination.
For a current credential, review Microsoft’s active certification offerings and compare role expectations, current objectives, and available scheduling information. The supplied sources explain Microsoft’s move from older MCSA, MCSD, and MCSE paths toward role-based certifications, but they do not establish a current 70-487 replacement. Make the comparison from the current official catalog rather than from an old exam title.
Step 2: turn the blueprint into observable tasks
Create a checklist using verbs rather than nouns. “Entity Framework” is a subject area; “write and explain a query that returns only the required related data” is an observable task. Do the same for data access, service use, storage, caching, transactions, XML, and the development life cycle.
Mark each task as explain, implement, troubleshoot, or compare. A topic marked only “recognize” is not ready if your real goal is engineering capability. A topic marked “troubleshoot” should have a reproducible failure and a test that confirms the fix.
Step 3: build a small integrated application
A compact application is more useful than a collection of disconnected code fragments. Build a web solution that reads and changes data, communicates with a service, handles XML or serialized content, and includes a deliberate caching or transaction decision.
Keep the project small enough to rebuild. Use separate commits or notes for each feature, record the reason for each design choice, and remove one dependency at a time to see how the application behaves. The exercise should reveal how data, service contracts, errors, and application code interact.
What is a sensible study sequence?
Study in dependency order: establish the application and data model, learn the access path, deepen Entity Framework query and change behavior, add services and storage, then test cross-cutting concerns such as caching, transactions, XML handling, and failures. This sequence prevents advanced features from hiding weak fundamentals.
The roadmap below is a practical recommendation, not an official Microsoft timetable. Adjust the pace to your existing experience and the current technology of the system you are maintaining.
Phase A: baseline the core skills
Start by explaining the application’s data flow without consulting notes. Identify the client, web layer, data-access layer, data source, service endpoints, and error boundaries. Then implement a minimal read operation and a minimal update operation.
If you cannot clearly state where validation occurs, where a transaction begins, or which layer owns a query, spend more time on architecture before moving to feature-specific review. This baseline prevents a common mistake: studying advanced service or storage terms while lacking a reliable model of the application path.
Phase B: prioritize the two weighted domains
Give the largest block of practice to “Accessing Data,” which represents 20–25% of the exam, and “Querying and Manipulating Data by Using the Entity Framework,” which represents 20–25% of the exam. The official weights justify this priority, but they do not eliminate the need to review the remaining objectives.
For each domain, alternate implementation and explanation. After writing a query or data-access routine, explain the generated behavior, likely failure modes, performance implications, and boundary conditions. If you can code a solution but cannot defend it, the topic is not secure.
Phase C: integrate remote services and Azure-related work
Next, connect the application to remote data and services. Practice service failure, timeout, invalid data, unavailable dependencies, and version or contract changes. Review the objective-domain technologies in context, including WCF Data Services and Azure DocumentDB/Cosmos DB.
Avoid turning this phase into an attempt to memorize every historical Azure interface. Focus on durable decisions: how data is represented, how a client communicates, how failures are surfaced, and how the application remains testable when a remote dependency is unavailable.
Phase D: test, explain, and consolidate
Finish by testing the integrated solution and explaining it from several viewpoints: developer, maintainer, and reviewer. Create a short list of unresolved questions and answer each with documentation or a repeatable experiment.
A strong final review is selective. Rebuild the areas that still fail, revisit the objective wording, and remove notes that merely repeat definitions. If your goal is a current certification, stop treating the old blueprint as the finish line and transfer the relevant concepts into the active role-based exam’s objectives.
How can you measure readiness without exam dumps?
Use working demonstrations, troubleshooting exercises, and closed-book explanations instead of leaked questions or memorized answer sets. Dumps cannot establish that you can design, implement, or diagnose a data and service solution, and they are especially unreliable for a retired exam whose material may be outdated.
Readiness means you can start with a requirement, choose an approach, implement a small solution, test normal and failure paths, and explain the trade-offs. That standard is more demanding than recalling a familiar phrase, but it is also more useful for real development work.
A practical self-check
Choose one task from each major area and perform it without step-by-step notes: retrieve and shape data, apply a change through Entity Framework, consume or expose a service, handle XML, choose a storage approach, and implement or critique caching or transaction behavior.
For every task, answer five questions: What requirement does this solve? Which layer owns it? What can fail? How will the failure be detected? What test proves the intended behavior? Record the answers. Gaps in the explanation usually indicate a deeper gap than a missing method name.
Use a mistake log, not a score log
Track the cause of each failed lab: unclear requirement, incorrect data model, query shape, service contract, error handling, test setup, or unsupported assumption. Then retest the same issue after making the correction.
A list of percentage scores from unofficial practice material is a weak readiness signal, particularly when the exam is retired and current question content is not evidenced. A mistake log shows whether your reasoning and implementation are improving.
Which preparation mistakes should you avoid?
The most damaging mistakes are strategic: preparing for an unavailable exam, treating the old title as a current certification path, and studying technology labels without building complete data and service flows. Correct those decisions before increasing study volume.
Technical mistakes matter too. Candidates often isolate Entity Framework from application design, ignore remote-service failure, treat caching as automatically beneficial, or test only successful requests. The objective areas are connected, so preparation should expose those connections.
Mistake: trusting a current-looking exam listing
A third-party page can display an old exam number, title, or practice product without proving that Microsoft still offers the exam. Check the official retirement policy and current Microsoft certification catalog before scheduling, purchasing preparation, or promising a credential to an employer.
If the official source does not support current delivery details, do not infer the duration, question count, language, price, score, or delivery method. Those details are omitted here because the supplied evidence does not establish them for 70-487.
Mistake: memorizing APIs without tracing data flow
A developer may recognize ADO.NET, Entity Framework, WCF Data Services, or Cosmos DB and still be unable to choose among them. Link each technology to a data shape, access pattern, failure mode, and testable requirement.
When reviewing a code sample, annotate the data source, query boundary, serialization boundary, transaction boundary, and error boundary. This turns recognition into a system-level understanding that can transfer to other frameworks and current role-based objectives.
Mistake: ignoring lifecycle and operational behavior
The objective-domain document includes the full software development life cycle for data and service solutions. Do not stop at implementation. Include design, testing, deployment considerations, maintenance, diagnostics, and changes to remote dependencies in your practice.
A solution that works once but cannot be tested, diagnosed, or safely changed is incomplete preparation for the stated candidate profile. Add tests and failure handling while the application is still small.
Mistake: confusing historical study with current certification
The old blueprint may be valuable for legacy development, but completing its topics does not demonstrate that you hold a current Microsoft credential. State the purpose accurately in your notes, profile, or learning plan.
If an employer asks for a current Azure developer certification, compare the requirement with an active Microsoft role-based certification. Microsoft’s retirement policy says retired exams cannot be taken to earn the associated credential, so an old study plan should not be presented as a current exam route.
What should you do next?
First, confirm your objective: current credential, legacy application work, or structured review of .NET data and service development. Then verify official availability and current requirements before spending money or setting a date. If you are studying the historical blueprint, begin with the two weighted domains and a small integrated lab.
Use the official objective-domain PDF for the historical scope, and use Microsoft’s retirement pages for status and transcript policy. Do not rely on this guide for live scheduling information, prices, delivery modes, or other details that can change or were not evidenced in the supplied research.
A decision checklist
Confirm whether 70-487 appears as an active offering in the official Microsoft certification system. If it does not, remove it from your scheduling plan.
If you already earned a related certification, check how it appears on your Microsoft Learn transcript and whether it is active or historical. Retirement does not by itself erase an earned record, but expiration affects its transcript section.
If you need a current credential, identify the target job role and compare active role-based certifications rather than assuming that the old 70-487 title has a direct substitute.
If you are maintaining a legacy solution, use the objective-domain topics to plan labs around data access, Entity Framework, service integration, storage, XML, caching, transactions, testing, and lifecycle work.
Keep evidence of your learning in the form of code, tests, design notes, and troubleshooting explanations. These are more useful than unsupported claims that you are prepared for an unavailable exam.
A first study session
In the first session, read the objective-domain document, list every technology and task you recognize, and mark the areas you can implement without a reference. Create a minimal data-backed web application and make one read path work from request to response.
In the next session, add a change operation and test invalid input and a failed dependency. Then begin a mistake log. This gives your preparation a measurable starting point without pretending that unofficial questions reproduce the retired exam.
Conclusion
70-487 is best approached as a retired, historical blueprint for web, data-access, Entity Framework, and Azure-related service development—not as a current exam booking target. Its most heavily weighted published domains are “Accessing Data” at 20–25% and “Querying and Manipulating Data by Using the Entity Framework” at 20–25%. Verify status through Microsoft, choose a current role-based path if certification is your goal, and use hands-on implementation, testing, and troubleshooting to turn the remaining objectives into durable development skills.
